/**
Set a string field (set_field(..., const string& value) form).
@param name the field name
@param name_len the length of name in bytes
@param value the field value
@return *this
*/
HTTPMessageType&
set_field(
const char* name,
size_t name_len,
const string& value
) {
return set_field(name, name_len, value.data(), value.size());
}
static int src_set_wr(void *blk, unsigned int wr)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->ctl, SRCCTL_WR, wr);
ctl->dirty.bf.ctl = 1;
return 0;
}
static int src_set_rom(void *blk, unsigned int rom)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->ctl, SRCCTL_ROM, rom);
ctl->dirty.bf.ctl = 1;
return 0;
}
static int src_set_la(void *blk, unsigned int la)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->la, SRCLA_LA, la);
ctl->dirty.bf.la = 1;
return 0;
}
static int dai_srt_set_et(void *blk, unsigned int et)
{
struct dai_ctrl_blk *ctl = blk;
set_field(&ctl->srtctl, SRTCTL_ET, et ? 1 : 0);
ctl->dirty.bf.srtctl = 1;
return 0;
}
static int src_set_bp(void *blk, unsigned int bp)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->ctl, SRCCTL_BP, bp);
ctl->dirty.bf.ctl = 1;
return 0;
}
static int src_set_ca(void *blk, unsigned int ca)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->ca, SRCCA_CA, ca);
ctl->dirty.bf.ca = 1;
return 0;
}
static int amixer_set_y(void *blk, unsigned int y)
{
struct amixer_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->amoplo, AMOPLO_Y, y);
ctl->dirty.bf.amoplo = 1;
return 0;
}
static int amixer_set_se(void *blk, unsigned int se)
{
struct amixer_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->amophi, AMOPHI_SE, se);
ctl->dirty.bf.amophi = 1;
return 0;
}
static int srcimp_mgr_set_imapuser(void *blk, unsigned int user)
{
struct srcimp_mgr_ctrl_blk *ctl = blk;
set_field(&ctl->srcimap.srcaim, SRCAIM_SRC, user);
ctl->dirty.bf.srcimap = 1;
return 0;
}
static int srcimp_mgr_set_imapnxt(void *blk, unsigned int next)
{
struct srcimp_mgr_ctrl_blk *ctl = blk;
set_field(&ctl->srcimap.srcaim, SRCAIM_NXT, next);
ctl->dirty.bf.srcimap = 1;
return 0;
}
static int srcimp_mgr_set_imaparc(void *blk, unsigned int slot)
{
struct srcimp_mgr_ctrl_blk *ctl = blk;
set_field(&ctl->srcimap.srcaim, SRCAIM_ARC, slot);
ctl->dirty.bf.srcimap = 1;
return 0;
}
static int src_set_pitch(void *blk, unsigned int pitch)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->mpr, MPRLH_PITCH, pitch);
ctl->dirty.bf.mpr = 1;
return 0;
}
/**
Set a string field (set_field(..., const void* value, size_t value_len)
form).
@param name the field name
@param value the field value
@param value_len the length of value in bytes
@return *this
*/
HTTPMessageType&
set_field(
const char* name,
const void* value,
size_t value_len
) {
return set_field(name, strlen(name), value, value_len);
}
static int src_set_st(void *blk, unsigned int st)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->ctl, SRCCTL_ST, st);
ctl->dirty.bf.ctl = 1;
return 0;
}
static int dai_srt_set_srcl(void *blk, unsigned int src)
{
struct dai_ctrl_blk *ctl = blk;
set_field(&ctl->srtctl, SRTCTL_SRCL, src);
ctl->dirty.bf.srtctl = 1;
return 0;
}
static int src_set_ilsz(void *blk, unsigned int ilsz)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->ctl, SRCCTL_ILSZ, ilsz);
ctl->dirty.bf.ctl = 1;
return 0;
}
static int dai_srt_set_rsr(void *blk, unsigned int rsr)
{
struct dai_ctrl_blk *ctl = blk;
set_field(&ctl->srtctl, SRTCTL_RSR, rsr);
ctl->dirty.bf.srtctl = 1;
return 0;
}
static int src_set_cisz(void *blk, unsigned int cisz)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->ccr, SRCCCR_CISZ, cisz);
ctl->dirty.bf.ccr = 1;
return 0;
}
static int dai_srt_set_drat(void *blk, unsigned int drat)
{
struct dai_ctrl_blk *ctl = blk;
set_field(&ctl->srtctl, SRTCTL_DRAT, drat);
ctl->dirty.bf.srtctl = 1;
return 0;
}
static int src_set_sa(void *blk, unsigned int sa)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->sa, SRCSA_SA, sa);
ctl->dirty.bf.sa = 1;
return 0;
}
static int src_set_vo(void *blk, unsigned int vo)
{
struct src_rsc_ctrl_blk *ctl = blk;
set_field(&ctl->ctl, SRCCTL_VO, vo);
ctl->dirty.bf.ctl = 1;
return 0;
}
/**
Set a string field (set_field(..., const char* value) form).
@param name the field name
@param name_len the length of name in bytes
@param value the field value
@return *this
*/
HTTPMessageType&
set_field(
const char* name,
size_t name_len,
const char* value
) {
return set_field(name, name_len, value, strlen(value));
}
void change_visibility(DexMethod* method) {
auto code = method->get_code();
always_assert(code != nullptr);
editable_cfg_adapter::iterate(code, [](MethodItemEntry& mie) {
auto insn = mie.insn;
if (insn->has_field()) {
auto cls = type_class(insn->get_field()->get_class());
if (cls != nullptr && !cls->is_external()) {
set_public(cls);
}
auto field =
resolve_field(insn->get_field(), is_sfield_op(insn->opcode())
? FieldSearch::Static : FieldSearch::Instance);
if (field != nullptr && field->is_concrete()) {
set_public(field);
set_public(type_class(field->get_class()));
// FIXME no point in rewriting opcodes in the method
insn->set_field(field);
}
} else if (insn->has_method()) {
auto cls = type_class(insn->get_method()->get_class());
if (cls != nullptr && !cls->is_external()) {
set_public(cls);
}
auto current_method = resolve_method(
insn->get_method(), opcode_to_search(insn));
if (current_method != nullptr && current_method->is_concrete()) {
set_public(current_method);
set_public(type_class(current_method->get_class()));
// FIXME no point in rewriting opcodes in the method
insn->set_method(current_method);
}
} else if (insn->has_type()) {
auto type = insn->get_type();
auto cls = type_class(type);
if (cls != nullptr && !cls->is_external()) {
set_public(cls);
}
}
return editable_cfg_adapter::LOOP_CONTINUE;
});
std::vector<DexType*> types;
if (code->editable_cfg_built()) {
code->cfg().gather_catch_types(types);
} else {
code->gather_catch_types(types);
}
for (auto type : types) {
auto cls = type_class(type);
if (cls != nullptr && !cls->is_external()) {
set_public(cls);
}
}
}
static int daio_mgr_dsb_dai(void *blk, unsigned int idx)
{
struct daio_mgr_ctrl_blk *ctl = blk;
set_field(&ctl->rxctl[idx], ARXCTL_EN, 0);
ctl->dirty.bf.arxctl |= (0x1 << idx);
return 0;
}
void MethodBlock::sfield_op(IROpcode opcode,
DexField* field,
Location& src_or_dst) {
always_assert(is_sfield_op(opcode));
if (is_sget(opcode)) {
auto sget = new IRInstruction(opcode);
sget->set_field(field);
src_or_dst.type = field->get_class();
push_instruction(sget);
push_instruction(
(new IRInstruction(opcode::move_result_pseudo_for_sget(opcode)))
->set_dest(src_or_dst.get_reg()));
} else {
auto sput = new IRInstruction(opcode);
sput->set_field(field)->set_src(0, src_or_dst.get_reg());
push_instruction(sput);
}
}
/*
* setup the RF FPGA registers based on
* icat status and console type
*/
int setupRfType()
{
uint64_t readDNA(void);
int status;
int icatFpgaFlag;
// determine if RF Controller FPGA is icat capable
icatFpgaFlag = fpgaIcatEnabled();
if (icatFpgaFlag > 0)
{
int icatID;
// determine if icat RF is attached to the controller
icatID = getIcatId();
diagPrint(NULL," ICAT ID: 0x%lx\n",icatID);
if (icatID != 0xa)
{
diagPrint(NULL," iCAT NOT Attached\n");
set_field(RF,transmitter_mode,0); // Non-ICAT RF
RfType = 0;
}
else
{
diagPrint(NULL,"iCAT Attached\n");
RfType = 1;
/* obtain the unique identifier for iCAT board */
/* used within the fail files */
iCAT_DNA = readDNA();
diagPrint(NULL," ICAT DNA: 0x%llx\n",iCAT_DNA);
}
if (ConsoleTypeFlag != 1) {
diagPrint(NULL," Setting for VNMRS Console\n");
// printf("Setting for VNMRS Console\n");
set_field(RF,console_type,0); // VNMRS = 0, 400-MR = 1
}
else {
diagPrint(NULL," Setting for 400-MR Console\n");
// printf("Setting for 400-MR Console\n");
set_field(RF,console_type,1); // VNMRS = 0, 400-MR = 1
}
set_field(RF,p2_disable,0); // This will then connect the interface on the P2 connector
}
return RfType;
}
void BitSequenceRRR::create_sampling(uint sample_rate) {
this->sample_rate = sample_rate;
/*cout << "===================" << endl;
cout << "length = " << length << endl;
cout << "ones = " << ones << endl;
cout << "C_len = " << C_len << endl;
cout << "C_field_bits = " << C_field_bits << endl;
cout << "O_len = " << O_len << endl;
cout << "O_bits_len = " << O_bits_len << endl;
cout << "sample_rate = " << sample_rate << endl;
cout << "C_alen = " << uint_len(C_len,C_field_bits) << endl;
cout << "O_alen = " << O_len << endl;*/
// Sampling for C
C_sampling_len = C_len/sample_rate+2;
C_sampling_field_bits = bits(ones);
if(C_sampling!=NULL) delete [] C_sampling;
C_sampling = new uint[max((uint)1,uint_len(C_sampling_len,C_sampling_field_bits))];
for(uint i=0; i<max((uint)1,uint_len(C_sampling_len,C_sampling_field_bits)); i++)
C_sampling[i] = 0;
uint sum = 0;
for(uint i=0; i<C_len; i++) {
if(i%sample_rate==0)
set_field(C_sampling,C_sampling_field_bits,i/sample_rate,sum);
sum += get_field(C,C_field_bits,i);
}
for(uint i=(C_len-1)/sample_rate+1; i<C_sampling_len; i++)
set_field(C_sampling,C_sampling_field_bits,i,sum);
// Sampling for O (table S) (Code separated from previous construction for readability)
O_pos_len = C_len/sample_rate+1;
O_pos_field_bits = bits(O_bits_len);
if(O_pos!=NULL) delete [] O_pos;
O_pos = new uint[uint_len(O_pos_len,O_pos_field_bits)];
for(uint i=0; i<uint_len(O_pos_len,O_pos_field_bits); i++)
O_pos[i] = 0;
uint pos = 0;
for(uint i=0; i<C_len; i++) {
if(i%sample_rate==0)
set_field(O_pos,O_pos_field_bits,i/sample_rate,pos);
pos += E->get_log2binomial(BLOCK_SIZE,get_field(C,C_field_bits,i));
}
}
void LogSequence2::set(size_t position, size_t value) {
if(IsMapped) {
throw "Data structure read-only when mapped.";
}
if(position>numentries) {
throw "Trying to modify a position out of the structure capacity. Use push_back() instead";
}
if(value>maxval) {
throw "Trying to insert a value bigger that expected. Please increase numbits when creating the data structure.";
}
set_field(array, numbits, position, value);
}
void per_L4_config(void)
{
vaddr_t base = SOC_CM_PER_REGS;
/* configure L4 interface clocks. */
set_field(base, CM_PER_L4LS_CLKCTRL,
CM_PER_L4LS_CLKCTRL_MODULEMODE,
CM_PER_L4LS_CLKCTRL_MODULEMODE_ENABLE);
set_field(base, CM_PER_L4LS_CLKSTCTRL,
CM_PER_L4LS_CLKSTCTRL_CLKTRCTRL,
CM_PER_L4LS_CLKSTCTRL_CLKTRCTRL_SW_WKUP);
wait_field(base, CM_PER_L4LS_CLKCTRL,
CM_PER_L4LS_CLKCTRL_IDLEST,
CM_PER_L4LS_CLKCTRL_IDLEST_FUNC << CM_PER_L4LS_CLKCTRL_IDLEST_SHIFT);
wait_field(base, CM_PER_L4LS_CLKSTCTRL,
CM_PER_L4LS_CLKSTCTRL_CLKACTIVITY_L4LS_GCLK,
CM_PER_L4LS_CLKSTCTRL_CLKACTIVITY_L4LS_GCLK);
}
