usr/src/lib/libm/common/C/libm.h

165

#define PIC_G_LOAD(insn,sym,dst) \

usr/src/lib/libm/common/C/libm.h

167

insn (%dst),%dst

usr/src/lib/libm/common/C/libm.h

178

#define PIC_G_LOAD(insn,sym,dst) \

usr/src/lib/libm/common/C/libm.h

180

insn (%dst),%dst

usr/src/lib/libm/common/C/libm.h

188

#define PIC_G_LOAD(insn,sym,dst) insn sym,%dst

usr/src/tools/smatch/src/compile-i386.c

1137

static const char *opbits(const char *insn, unsigned int bits)

usr/src/tools/smatch/src/compile-i386.c

1150

sprintf(opbits_str, "%s%c", insn, c);

usr/src/tools/smatch/src/compile-i386.c

1191

insn("mov", src, dest, NULL);

usr/src/tools/smatch/src/compile-i386.c

1227

insn(opbits(opname, bits), src, dest, comment);

usr/src/tools/smatch/src/compile-i386.c

1272

insn(opbits("cmp", right_bits), right, reg2, NULL);

usr/src/tools/smatch/src/compile-i386.c

1276

insn(opname, byte_reg(reg1), NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1295

insn("movl", val, new, NULL);

usr/src/tools/smatch/src/compile-i386.c

1329

insn("div", reg, REG_EAX, NULL);

usr/src/tools/smatch/src/compile-i386.c

1426

insn(opstr, src, dest, NULL);

usr/src/tools/smatch/src/compile-i386.c

1449

insn("test", reg, reg, NULL);

usr/src/tools/smatch/src/compile-i386.c

1457

insn("jz", target_val, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1475

insn("jmp", cond_end_st, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1525

insn(opname, addr, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1550

insn("jmp", jmplbl, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1600

insn("test", reg_cond, reg_cond, NULL);

usr/src/tools/smatch/src/compile-i386.c

1601

insn("cmovz", reg_false, reg_true, NULL);

usr/src/tools/smatch/src/compile-i386.c

1684

insn("test", REG_EAX, REG_EAX, NULL);

usr/src/tools/smatch/src/compile-i386.c

1685

insn("setz", REG_DL, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1695

insn(opname, REG_EAX, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

174

char insn[32];

usr/src/tools/smatch/src/compile-i386.c

1741

insn("cmpl", case_val, REG_EAX, NULL);

usr/src/tools/smatch/src/compile-i386.c

1745

insn("je", labelsym, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1754

insn("jl", label, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1757

insn("cmpl", case_val, REG_EAX, NULL);

usr/src/tools/smatch/src/compile-i386.c

1765

insn("jg", label, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1768

insn("jmp", labelsym, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1777

insn("jmp", labelsym, NULL, "default");

usr/src/tools/smatch/src/compile-i386.c

1782

insn("jmp", label, NULL, "goto end of switch");

usr/src/tools/smatch/src/compile-i386.c

1939

insn("jmp", lbv, NULL, "go to loop bottom");

usr/src/tools/smatch/src/compile-i386.c

1951

insn("test", REG_EAX, REG_EAX, NULL);

usr/src/tools/smatch/src/compile-i386.c

1952

insn("jz", lbv, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

1963

insn("jmp", lbv, NULL, "go to loop top");

usr/src/tools/smatch/src/compile-i386.c

1969

insn("jmp", lbv, NULL, "go to loop top");

usr/src/tools/smatch/src/compile-i386.c

1979

insn("test", REG_EAX, REG_EAX, NULL);

usr/src/tools/smatch/src/compile-i386.c

1980

insn("jnz", lbv, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

2047

insn("jmp", lbv, NULL, "'break'; go to loop bottom");

usr/src/tools/smatch/src/compile-i386.c

2052

insn("jmp", lbv, NULL, "'continue'; go to loop top");

usr/src/tools/smatch/src/compile-i386.c

2055

insn("jmp", labelsym, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

2093

insn("pushl", new, NULL,

usr/src/tools/smatch/src/compile-i386.c

2114

insn("call", direct_stor, NULL, NULL);

usr/src/tools/smatch/src/compile-i386.c

2128

insn("addl", val, REG_ESP, NULL);

usr/src/tools/smatch/src/compile-i386.c

626

static void insn(const char *insn, struct storage *op1, struct storage *op2,

usr/src/tools/smatch/src/compile-i386.c

632

assert(insn != NULL);

usr/src/tools/smatch/src/compile-i386.c

634

strcpy(atom->insn, insn);

usr/src/tools/smatch/src/compile-i386.c

725

atom->insn, tmp, stor_op_name(op2), comment);

usr/src/tools/smatch/src/compile-i386.c

728

atom->insn, stor_op_name(op1),

usr/src/tools/smatch/src/compile-i386.c

732

atom->insn,

usr/src/tools/smatch/src/compile-i386.c

883

insn("addl", val, REG_ESP, NULL);

usr/src/tools/smatch/src/compile-i386.c

886

insn("ret", NULL, NULL, NULL);

usr/src/tools/smatch/src/cse.c

100

hash += hashval(insn->orig_type->bit_size);

usr/src/tools/smatch/src/cse.c

106

FOR_EACH_PTR(insn->phi_list, phi) {

usr/src/tools/smatch/src/cse.c

126

add_instruction(insn_hash_table + hash, insn);

usr/src/tools/smatch/src/cse.c

264

static struct instruction * cse_one_instruction(struct instruction *insn, struct instruction *def)

usr/src/tools/smatch/src/cse.c

266

convert_instruction_target(insn, def->target);

usr/src/tools/smatch/src/cse.c

268

kill_instruction(insn);

usr/src/tools/smatch/src/cse.c

287

static inline void remove_instruction(struct instruction_list **list, struct instruction *insn, int count)

usr/src/tools/smatch/src/cse.c

289

delete_ptr_list_entry((struct ptr_list **)list, insn, count);

usr/src/tools/smatch/src/cse.c

292

static void add_instruction_to_end(struct instruction *insn, struct basic_block *bb)

usr/src/tools/smatch/src/cse.c

295

insn->bb = bb;

usr/src/tools/smatch/src/cse.c

296

add_instruction(&bb->insns, insn);

usr/src/tools/smatch/src/cse.c

316

struct instruction *insn;

usr/src/tools/smatch/src/cse.c

317

FOR_EACH_PTR(b1->insns, insn) {

usr/src/tools/smatch/src/cse.c

318

if (insn == i1)

usr/src/tools/smatch/src/cse.c

320

if (insn == i2)

usr/src/tools/smatch/src/cse.c

322

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/cse.c

353

struct instruction *insn, *last;

usr/src/tools/smatch/src/cse.c

358

FOR_EACH_PTR(*list, insn) {

usr/src/tools/smatch/src/cse.c

359

if (!insn->bb)

usr/src/tools/smatch/src/cse.c

362

if (!insn_compare(last, insn))

usr/src/tools/smatch/src/cse.c

363

insn = try_to_cse(ep, last, insn);

usr/src/tools/smatch/src/cse.c

365

last = insn;

usr/src/tools/smatch/src/cse.c

366

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/cse.c

38

void cse_collect(struct instruction *insn)

usr/src/tools/smatch/src/cse.c

42

hash = (insn->opcode << 3) + (insn->size >> 3);

usr/src/tools/smatch/src/cse.c

43

switch (insn->opcode) {

usr/src/tools/smatch/src/cse.c

45

hash += hashval(insn->src3);

usr/src/tools/smatch/src/cse.c

73

hash += hashval(insn->src2);

usr/src/tools/smatch/src/cse.c

80

hash += hashval(insn->src1);

usr/src/tools/smatch/src/cse.c

84

hash += hashval(insn->val);

usr/src/tools/smatch/src/cse.c

88

hash += hashval(insn->fvalue);

usr/src/tools/smatch/src/cse.c

95

if (!insn->orig_type || insn->orig_type->bit_size < 0)

usr/src/tools/smatch/src/cse.c

97

hash += hashval(insn->src);

usr/src/tools/smatch/src/cse.h

8

void cse_collect(struct instruction *insn);

usr/src/tools/smatch/src/example.c

1017

static void generate_copy(struct bb_state *state, struct instruction *insn)

usr/src/tools/smatch/src/example.c

1019

struct hardreg *src = getreg(state, insn->src, insn->target);

usr/src/tools/smatch/src/example.c

1020

kill_pseudo(state, insn->target);

usr/src/tools/smatch/src/example.c

1021

add_pseudo_reg(state, insn->target, src);

usr/src/tools/smatch/src/example.c

1024

static void generate_cast(struct bb_state *state, struct instruction *insn)

usr/src/tools/smatch/src/example.c

1026

struct hardreg *src = getreg(state, insn->src, insn->target);

usr/src/tools/smatch/src/example.c

1028

unsigned int old = insn->orig_type ? insn->orig_type->bit_size : 0;

usr/src/tools/smatch/src/example.c

1029

unsigned int new = insn->size;

usr/src/tools/smatch/src/example.c

1036

add_pseudo_reg(state, insn->target, src);

usr/src/tools/smatch/src/example.c

1040

dst = target_copy_reg(state, src, insn->target);

usr/src/tools/smatch/src/example.c

1042

if (insn->orig_type && (insn->orig_type->ctype.modifiers & MOD_SIGNED)) {

usr/src/tools/smatch/src/example.c

1048

output_insn(state, "andl.%d $%#llx,%s", insn->size, mask, dst->name);

usr/src/tools/smatch/src/example.c

1050

add_pseudo_reg(state, insn->target, dst);

usr/src/tools/smatch/src/example.c

1093

static void generate_switch(struct bb_state *state, struct instruction *insn)

usr/src/tools/smatch/src/example.c

1099

output_insn(state, "unimplemented: %s", show_instruction(insn));

usr/src/tools/smatch/src/example.c

1116

static void generate_call(struct bb_state *state, struct instruction *insn)

usr/src/tools/smatch/src/example.c

1121

FOR_EACH_PTR(insn->arguments, arg) {

usr/src/tools/smatch/src/example.c

1128

output_insn(state, "call %s", show_pseudo(insn->func));

usr/src/tools/smatch/src/example.c

1131

if (insn->target && insn->target != VOID)

usr/src/tools/smatch/src/example.c

1132

add_pseudo_reg(state, insn->target, hardregs+0);

usr/src/tools/smatch/src/example.c

1135

static void generate_select(struct bb_state *state, struct instruction *insn)

usr/src/tools/smatch/src/example.c

1140

src1 = getreg(state, insn->src2, NULL);

usr/src/tools/smatch/src/example.c

1141

dst = copy_reg(state, src1, insn->target);

usr/src/tools/smatch/src/example.c

1142

add_pseudo_reg(state, insn->target, dst);

usr/src/tools/smatch/src/example.c

1143

src2 = getreg(state, insn->src3, insn->target);

usr/src/tools/smatch/src/example.c

1145

if (state->cc_target == insn->src1) {

usr/src/tools/smatch/src/example.c

1148

struct hardreg *reg = getreg(state, insn->src1, NULL);

usr/src/tools/smatch/src/example.c

1326

static void generate_asm(struct bb_state *state, struct instruction *insn)

usr/src/tools/smatch/src/example.c

1328

const char *str = insn->string;

usr/src/tools/smatch/src/example.c

1330

if (insn->asm_rules->outputs || insn->asm_rules->inputs) {

usr/src/tools/smatch/src/example.c

1333

arg = generate_asm_outputs(state, insn->asm_rules->outputs, asm_arguments);

usr/src/tools/smatch/src/example.c

1334

arg = generate_asm_inputs(state, insn->asm_rules->inputs, arg);

usr/src/tools/smatch/src/example.c

1340

static void generate_compare(struct bb_state *state, struct instruction *insn)

usr/src/tools/smatch/src/example.c

1347

opcode = insn->opcode;

usr/src/tools/smatch/src/example.c

1353

src = getreg(state, insn->src1, insn->target);

usr/src/tools/smatch/src/example.c

1354

src2 = generic(state, insn->src2);

usr/src/tools/smatch/src/example.c

1356

output_insn(state, "cmp.%d %s,%s", insn->size, src2, src->name);

usr/src/tools/smatch/src/example.c

1358

add_cc_cache(state, opcode, insn->target);

usr/src/tools/smatch/src/example.c

1361

static void generate_one_insn(struct instruction *insn, struct bb_state *state)

usr/src/tools/smatch/src/example.c

1364

output_comment(state, "%s", show_instruction(insn));

usr/src/tools/smatch/src/example.c

1366

switch (insn->opcode) {

usr/src/tools/smatch/src/example.c

1368

struct symbol *sym = insn->bb->ep->name;

usr/src/tools/smatch/src/example.c

1386

generate_store(insn, state);

usr/src/tools/smatch/src/example.c

1390

generate_load(insn, state);

usr/src/tools/smatch/src/example.c

1394

mark_pseudo_dead(state, insn->target);

usr/src/tools/smatch/src/example.c

1398

generate_copy(state, insn);

usr/src/tools/smatch/src/example.c

1403

generate_commutative_binop(state, insn);

usr/src/tools/smatch/src/example.c

1409

generate_binop(state, insn);

usr/src/tools/smatch/src/example.c

1413

generate_compare(state, insn);

usr/src/tools/smatch/src/example.c

1424

generate_cast(state, insn);

usr/src/tools/smatch/src/example.c

1428

generate_select(state, insn);

usr/src/tools/smatch/src/example.c

1433

generate_branch(state, insn);

usr/src/tools/smatch/src/example.c

1437

generate_switch(state, insn);

usr/src/tools/smatch/src/example.c

1441

generate_call(state, insn);

usr/src/tools/smatch/src/example.c

1445

generate_ret(state, insn);

usr/src/tools/smatch/src/example.c

1449

generate_asm(state, insn);

usr/src/tools/smatch/src/example.c

1455

output_insn(state, "unimplemented: %s", show_instruction(insn));

usr/src/tools/smatch/src/example.c

1685

struct instruction *insn;

usr/src/tools/smatch/src/example.c

1706

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/example.c

1707

if (!insn->bb)

usr/src/tools/smatch/src/example.c

1709

generate_one_insn(insn, state);

usr/src/tools/smatch/src/example.c

1710

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/example.c

1872

static void set_up_arch_switch(struct basic_block *bb, struct instruction *insn)

usr/src/tools/smatch/src/example.c

1874

pseudo_t pseudo = insn->cond;

usr/src/tools/smatch/src/example.c

1892

struct instruction *insn = last_instruction(bb->insns);

usr/src/tools/smatch/src/example.c

1893

if (!insn)

usr/src/tools/smatch/src/example.c

1895

switch (insn->opcode) {

usr/src/tools/smatch/src/example.c

1897

set_up_arch_exit(bb, insn);

usr/src/tools/smatch/src/example.c

1900

set_up_arch_switch(bb, insn);

usr/src/tools/smatch/src/example.c

886

static void do_binop(struct bb_state *state, struct instruction *insn, pseudo_t val1, pseudo_t val2)

usr/src/tools/smatch/src/example.c

888

const char *op = opcodes[insn->opcode];

usr/src/tools/smatch/src/example.c

889

struct operand *src = get_register_operand(state, val1, insn->target);

usr/src/tools/smatch/src/example.c

893

dst = target_copy_reg(state, src->reg, insn->target);

usr/src/tools/smatch/src/example.c

894

output_insn(state, "%s.%d %s,%s", op, insn->size, show_op(state, src2), dst->name);

usr/src/tools/smatch/src/example.c

897

add_pseudo_reg(state, insn->target, dst);

usr/src/tools/smatch/src/example.c

900

static void generate_binop(struct bb_state *state, struct instruction *insn)

usr/src/tools/smatch/src/example.c

903

do_binop(state, insn, insn->src1, insn->src2);

usr/src/tools/smatch/src/example.c

921

static void generate_commutative_binop(struct bb_state *state, struct instruction *insn)

usr/src/tools/smatch/src/example.c

927

src1 = insn->src1;

usr/src/tools/smatch/src/example.c

928

src2 = insn->src2;

usr/src/tools/smatch/src/example.c

941

if (reg2 != preferred_reg(state, insn->target))

usr/src/tools/smatch/src/example.c

946

src2 = insn->src1;

usr/src/tools/smatch/src/example.c

948

do_binop(state, insn, src1, src2);

usr/src/tools/smatch/src/example.c

979

static void generate_store(struct instruction *insn, struct bb_state *state)

usr/src/tools/smatch/src/example.c

981

output_insn(state, "mov.%d %s,%s", insn->size, reg_or_imm(state, insn->target), address(state, insn));

usr/src/tools/smatch/src/example.c

984

static void generate_load(struct instruction *insn, struct bb_state *state)

usr/src/tools/smatch/src/example.c

986

const char *input = address(state, insn);

usr/src/tools/smatch/src/example.c

990

dst = target_reg(state, insn->target, NULL);

usr/src/tools/smatch/src/example.c

991

output_insn(state, "mov.%d %s,%s", insn->size, input, dst->name);

usr/src/tools/smatch/src/flow.c

101

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/flow.c

165

struct instruction *insn;

usr/src/tools/smatch/src/flow.c

166

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/flow.c

167

if (!insn->bb)

usr/src/tools/smatch/src/flow.c

169

switch (insn->opcode) {

usr/src/tools/smatch/src/flow.c

175

if (!insn->type)

usr/src/tools/smatch/src/flow.c

177

if (insn->is_volatile)

usr/src/tools/smatch/src/flow.c

192

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/flow.c

215

struct instruction *insn;

usr/src/tools/smatch/src/flow.c

220

insn = last_instruction(target->insns);

usr/src/tools/smatch/src/flow.c

221

if (!insn || insn->opcode != OP_CBR || insn->cond != br->cond)

usr/src/tools/smatch/src/flow.c

228

final = bb_true ? insn->bb_true : insn->bb_false;

usr/src/tools/smatch/src/flow.c

244

insert_branch(target, insn, final);

usr/src/tools/smatch/src/flow.c

284

void convert_instruction_target(struct instruction *insn, pseudo_t src)

usr/src/tools/smatch/src/flow.c

291

target = insn->target;

usr/src/tools/smatch/src/flow.c

305

void convert_load_instruction(struct instruction *insn, pseudo_t src)

usr/src/tools/smatch/src/flow.c

307

convert_instruction_target(insn, src);

usr/src/tools/smatch/src/flow.c

308

kill_instruction(insn);

usr/src/tools/smatch/src/flow.c

346

int dominates(pseudo_t pseudo, struct instruction *insn, struct instruction *dom, int local)

usr/src/tools/smatch/src/flow.c

358

if (distinct_symbols(insn->src, dom->src))

usr/src/tools/smatch/src/flow.c

363

if (!same_memop(insn, dom)) {

usr/src/tools/smatch/src/flow.c

366

if (!overlapping_memop(insn, dom))

usr/src/tools/smatch/src/flow.c

377

void rewrite_load_instruction(struct instruction *insn, struct pseudo_list *dominators)

usr/src/tools/smatch/src/flow.c

397

convert_load_instruction(insn, new);

usr/src/tools/smatch/src/flow.c

405

if (insn->src->type != PSEUDO_SYM)

usr/src/tools/smatch/src/flow.c

406

kill_use(&insn->src);

usr/src/tools/smatch/src/flow.c

407

insn->opcode = OP_PHI;

usr/src/tools/smatch/src/flow.c

408

insn->phi_list = dominators;

usr/src/tools/smatch/src/flow.c

431

struct instruction *insn;

usr/src/tools/smatch/src/flow.c

437

FOR_EACH_PTR_REVERSE(bb->insns, insn) {

usr/src/tools/smatch/src/flow.c

438

if (!insn->bb)

usr/src/tools/smatch/src/flow.c

440

switch (insn->opcode) {

usr/src/tools/smatch/src/flow.c

442

if (insn->src == pseudo)

usr/src/tools/smatch/src/flow.c

446

if (insn->src == pseudo) {

usr/src/tools/smatch/src/flow.c

447

kill_instruction_force(insn);

usr/src/tools/smatch/src/flow.c

457

if (!local && insn->src->type != PSEUDO_SYM)

usr/src/tools/smatch/src/flow.c

459

} END_FOR_EACH_PTR_REVERSE(insn);

usr/src/tools/smatch/src/flow.c

468

void check_access(struct instruction *insn)

usr/src/tools/smatch/src/flow.c

470

pseudo_t pseudo = insn->src;

usr/src/tools/smatch/src/flow.c

472

if (insn->bb && pseudo->type == PSEUDO_SYM) {

usr/src/tools/smatch/src/flow.c

473

int offset = insn->offset, bit = bytes_to_bits(offset) + insn->size;

usr/src/tools/smatch/src/flow.c

477

if (insn->tainted)

usr/src/tools/smatch/src/flow.c

479

warning(insn->pos, "invalid access %s '%s' (%d %d)",

usr/src/tools/smatch/src/flow.c

483

insn->tainted = 1;

usr/src/tools/smatch/src/flow.c

510

struct instruction *insn = pu->insn;

usr/src/tools/smatch/src/flow.c

511

if (insn->opcode == OP_STORE) {

usr/src/tools/smatch/src/flow.c

512

kill_instruction_force(insn);

usr/src/tools/smatch/src/flow.c

540

static void kill_defs(struct instruction *insn)

usr/src/tools/smatch/src/flow.c

542

pseudo_t target = insn->target;

usr/src/tools/smatch/src/flow.c

546

if (target->def != insn)

usr/src/tools/smatch/src/flow.c

549

convert_instruction_target(insn, VOID);

usr/src/tools/smatch/src/flow.c

554

struct instruction *insn;

usr/src/tools/smatch/src/flow.c

557

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/flow.c

558

if (!insn->bb)

usr/src/tools/smatch/src/flow.c

560

kill_instruction_force(insn);

usr/src/tools/smatch/src/flow.c

561

kill_defs(insn);

usr/src/tools/smatch/src/flow.c

566

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/flow.c

57

struct instruction *insn = pseudo->def;

usr/src/tools/smatch/src/flow.c

60

if (insn->opcode == OP_SYMADDR && insn->target == pseudo)

usr/src/tools/smatch/src/flow.c

600

struct instruction *insn = last_instruction(bb->insns);

usr/src/tools/smatch/src/flow.c

602

if (!insn)

usr/src/tools/smatch/src/flow.c

609

switch (insn->opcode) {

usr/src/tools/smatch/src/flow.c

611

changed |= rewrite_branch(bb, &insn->bb_false, old, new);

usr/src/tools/smatch/src/flow.c

614

changed |= rewrite_branch(bb, &insn->bb_true, old, new);

usr/src/tools/smatch/src/flow.c

619

FOR_EACH_PTR(insn->multijmp_list, jmp) {

usr/src/tools/smatch/src/flow.c

732

struct instruction *first, *insn;

usr/src/tools/smatch/src/flow.c

803

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/flow.c

804

if (!insn->bb)

usr/src/tools/smatch/src/flow.c

806

assert(insn->bb == bb);

usr/src/tools/smatch/src/flow.c

807

insn->bb = parent;

usr/src/tools/smatch/src/flow.c

808

add_instruction(&parent->insns, insn);

usr/src/tools/smatch/src/flow.c

809

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/flow.c

93

struct instruction *insn;

usr/src/tools/smatch/src/flow.c

94

FOR_EACH_PTR(src->insns, insn) {

usr/src/tools/smatch/src/flow.c

95

if (!insn->bb)

usr/src/tools/smatch/src/flow.c

97

if (insn->opcode != OP_PHI)

usr/src/tools/smatch/src/flow.c

99

if (pseudo_in_list(target->needs, insn->target))

usr/src/tools/smatch/src/flow.h

22

extern void convert_instruction_target(struct instruction *insn, pseudo_t src);

usr/src/tools/smatch/src/flow.h

32

static inline int kill_instruction(struct instruction *insn)

usr/src/tools/smatch/src/flow.h

34

return kill_insn(insn, 0);

usr/src/tools/smatch/src/flow.h

36

static inline int kill_instruction_force(struct instruction *insn)

usr/src/tools/smatch/src/flow.h

38

return kill_insn(insn, 1);

usr/src/tools/smatch/src/flow.h

41

void check_access(struct instruction *insn);

usr/src/tools/smatch/src/flow.h

44

int dominates(pseudo_t pseudo, struct instruction *insn, struct instruction *dom, int local);

usr/src/tools/smatch/src/graph.c

123

struct instruction *insn;

usr/src/tools/smatch/src/graph.c

134

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/graph.c

135

if (!insn->bb)

usr/src/tools/smatch/src/graph.c

137

if (insn->opcode == OP_CALL &&

usr/src/tools/smatch/src/graph.c

138

internal == !(insn->func->sym->ctype.modifiers & MOD_EXTERN)) {

usr/src/tools/smatch/src/graph.c

142

if (insn->func->type == PSEUDO_SYM) {

usr/src/tools/smatch/src/graph.c

143

for (sym = insn->func->sym->ident->symbols;

usr/src/tools/smatch/src/graph.c

153

insn->pos.line, insn->pos.line, insn->pos.pos);

usr/src/tools/smatch/src/graph.c

157

bb, show_pseudo(insn->func),

usr/src/tools/smatch/src/graph.c

158

insn->pos.line, insn->pos.line, insn->pos.pos);

usr/src/tools/smatch/src/graph.c

161

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/graph.c

47

struct instruction *insn;

usr/src/tools/smatch/src/graph.c

76

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/graph.c

77

if (!insn->bb)

usr/src/tools/smatch/src/graph.c

79

switch(insn->opcode) {

usr/src/tools/smatch/src/graph.c

81

if (insn->src->type == PSEUDO_SYM) {

usr/src/tools/smatch/src/graph.c

82

printf("%s store(%s)", s, show_ident(insn->src->sym->ident));

usr/src/tools/smatch/src/graph.c

88

if (insn->src->type == PSEUDO_SYM) {

usr/src/tools/smatch/src/graph.c

89

printf("%s load(%s)", s, show_ident(insn->src->sym->ident));

usr/src/tools/smatch/src/graph.c

99

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/ir.c

101

FOR_EACH_PTR(insn->multijmp_list, jmp) {

usr/src/tools/smatch/src/ir.c

102

err = check_branch(ep, insn, jmp->target);

usr/src/tools/smatch/src/ir.c

110

static int check_return(struct instruction *insn)

usr/src/tools/smatch/src/ir.c

112

struct symbol *ctype = insn->type;

usr/src/tools/smatch/src/ir.c

114

if (ctype && ctype->bit_size > 0 && insn->src == VOID) {

usr/src/tools/smatch/src/ir.c

115

sparse_error(insn->pos, "return without value");

usr/src/tools/smatch/src/ir.c

121

static int validate_insn(struct entrypoint *ep, struct instruction *insn)

usr/src/tools/smatch/src/ir.c

125

switch (insn->opcode) {

usr/src/tools/smatch/src/ir.c

128

err += check_user(insn, insn->src3);

usr/src/tools/smatch/src/ir.c

132

err += check_user(insn, insn->src2);

usr/src/tools/smatch/src/ir.c

139

err += check_user(insn, insn->src1);

usr/src/tools/smatch/src/ir.c

14

if (!insn->phi_list)

usr/src/tools/smatch/src/ir.c

143

err += check_branch(ep, insn, insn->bb_true);

usr/src/tools/smatch/src/ir.c

144

err += check_branch(ep, insn, insn->bb_false);

usr/src/tools/smatch/src/ir.c

147

err += check_user(insn, insn->cond);

usr/src/tools/smatch/src/ir.c

151

err += check_phi_node(insn);

usr/src/tools/smatch/src/ir.c

159

err += check_user(insn, insn->target);

usr/src/tools/smatch/src/ir.c

163

err += check_user(insn, insn->src);

usr/src/tools/smatch/src/ir.c

167

err += check_return(insn);

usr/src/tools/smatch/src/ir.c

17

FOR_EACH_PTR(insn->phi_list, p) {

usr/src/tools/smatch/src/ir.c

171

err += check_branch(ep, insn, insn->bb_true);

usr/src/tools/smatch/src/ir.c

174

err += check_switch(ep, insn);

usr/src/tools/smatch/src/ir.c

195

struct instruction *insn;

usr/src/tools/smatch/src/ir.c

196

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/ir.c

197

if (!insn->bb)

usr/src/tools/smatch/src/ir.c

199

err += validate_insn(ep, insn);

usr/src/tools/smatch/src/ir.c

200

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/ir.c

26

static int check_phi_node(struct instruction *insn)

usr/src/tools/smatch/src/ir.c

32

if (!has_users(insn->target))

usr/src/tools/smatch/src/ir.c

35

if (bb_list_size(insn->bb->parents) != nbr_phi_operands(insn)) {

usr/src/tools/smatch/src/ir.c

36

sparse_error(insn->pos, "bad number of phi operands in:\n\t%s",

usr/src/tools/smatch/src/ir.c

37

show_instruction(insn));

usr/src/tools/smatch/src/ir.c

38

info(insn->pos, "parents: %d", bb_list_size(insn->bb->parents));

usr/src/tools/smatch/src/ir.c

39

info(insn->pos, "phisrcs: %d", nbr_phi_operands(insn));

usr/src/tools/smatch/src/ir.c

43

PREPARE_PTR_LIST(insn->bb->parents, par);

usr/src/tools/smatch/src/ir.c

44

FOR_EACH_PTR(insn->phi_list, phi) {

usr/src/tools/smatch/src/ir.c

62

static int check_user(struct instruction *insn, pseudo_t pseudo)

usr/src/tools/smatch/src/ir.c

67

show_entry(insn->bb->ep);

usr/src/tools/smatch/src/ir.c

68

sparse_error(insn->pos, "null pseudo in %s", show_instruction(insn));

usr/src/tools/smatch/src/ir.c

77

show_entry(insn->bb->ep);

usr/src/tools/smatch/src/ir.c

78

sparse_error(insn->pos, "wrong usage for %s in %s", show_pseudo(pseudo),

usr/src/tools/smatch/src/ir.c

79

show_instruction(insn));

usr/src/tools/smatch/src/ir.c

88

static int check_branch(struct entrypoint *ep, struct instruction *insn, struct basic_block *bb)

usr/src/tools/smatch/src/ir.c

9

static int nbr_phi_operands(struct instruction *insn)

usr/src/tools/smatch/src/ir.c

92

sparse_error(insn->pos, "branch to dead BB: %s", show_instruction(insn));

usr/src/tools/smatch/src/ir.c

96

static int check_switch(struct entrypoint *ep, struct instruction *insn)

usr/src/tools/smatch/src/linearize.c

1043

static void taint_undefined_behaviour(struct instruction *insn)

usr/src/tools/smatch/src/linearize.c

1047

switch (insn->opcode) {

usr/src/tools/smatch/src/linearize.c

1051

src2 = insn->src2;

usr/src/tools/smatch/src/linearize.c

1054

if ((unsigned long long)src2->value >= insn->size)

usr/src/tools/smatch/src/linearize.c

1055

insn->tainted = 1;

usr/src/tools/smatch/src/linearize.c

1062

struct instruction *insn = alloc_typed_instruction(op, ctype);

usr/src/tools/smatch/src/linearize.c

1063

pseudo_t target = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

1064

insn->target = target;

usr/src/tools/smatch/src/linearize.c

1065

use_pseudo(insn, left, &insn->src1);

usr/src/tools/smatch/src/linearize.c

1066

use_pseudo(insn, right, &insn->src2);

usr/src/tools/smatch/src/linearize.c

1067

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

1073

struct instruction *insn = alloc_typed_instruction(OP_SETVAL, ctype);

usr/src/tools/smatch/src/linearize.c

1074

pseudo_t target = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

1075

insn->target = target;

usr/src/tools/smatch/src/linearize.c

1076

insn->val = val;

usr/src/tools/smatch/src/linearize.c

1077

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

1083

struct instruction *insn = alloc_typed_instruction(OP_SETFVAL, ctype);

usr/src/tools/smatch/src/linearize.c

1084

pseudo_t target = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

1085

insn->target = target;

usr/src/tools/smatch/src/linearize.c

1086

insn->fvalue = fval;

usr/src/tools/smatch/src/linearize.c

1087

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

1093

struct instruction *insn = alloc_instruction(OP_SYMADDR, bits_in_pointer);

usr/src/tools/smatch/src/linearize.c

1094

pseudo_t target = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

1096

insn->target = target;

usr/src/tools/smatch/src/linearize.c

1097

use_pseudo(insn, symbol_pseudo(ep, sym), &insn->src);

usr/src/tools/smatch/src/linearize.c

1098

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

1168

struct instruction *insn = alloc_typed_instruction(op, ctype);

usr/src/tools/smatch/src/linearize.c

1169

pseudo_t new = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

1171

insn->target = new;

usr/src/tools/smatch/src/linearize.c

1172

use_pseudo(insn, src, &insn->src1);

usr/src/tools/smatch/src/linearize.c

1173

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

1188

struct instruction *insn = alloc_typed_instruction(OP_SLICE, expr->ctype);

usr/src/tools/smatch/src/linearize.c

1189

pseudo_t new = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

1191

insn->target = new;

usr/src/tools/smatch/src/linearize.c

1192

insn->from = expr->r_bitpos;

usr/src/tools/smatch/src/linearize.c

1193

insn->len = expr->r_nrbits;

usr/src/tools/smatch/src/linearize.c

1194

use_pseudo(insn, pre, &insn->base);

usr/src/tools/smatch/src/linearize.c

1195

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

1360

struct instruction *insn;

usr/src/tools/smatch/src/linearize.c

1395

insn = alloc_typed_instruction(opcode, to);

usr/src/tools/smatch/src/linearize.c

1396

result = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

1397

insn->target = result;

usr/src/tools/smatch/src/linearize.c

1398

insn->orig_type = from;

usr/src/tools/smatch/src/linearize.c

1399

use_pseudo(insn, src, &insn->src);

usr/src/tools/smatch/src/linearize.c

1400

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

1491

struct instruction *insn = alloc_typed_instruction(OP_CALL, expr->ctype);

usr/src/tools/smatch/src/linearize.c

1506

add_symbol(&insn->fntypes, fntype);

usr/src/tools/smatch/src/linearize.c

1509

use_pseudo(insn, new, add_pseudo(&insn->arguments, new));

usr/src/tools/smatch/src/linearize.c

1510

add_symbol(&insn->fntypes, arg->ctype);

usr/src/tools/smatch/src/linearize.c

1521

use_pseudo(insn, call, &insn->func);

usr/src/tools/smatch/src/linearize.c

1524

retval = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

1525

insn->target = retval;

usr/src/tools/smatch/src/linearize.c

1526

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

1544

insn = alloc_instruction(OP_CONTEXT, 0);

usr/src/tools/smatch/src/linearize.c

1545

insn->increment = context_diff;

usr/src/tools/smatch/src/linearize.c

1546

insn->check = check;

usr/src/tools/smatch/src/linearize.c

1547

insn->context_expr = context->context;

usr/src/tools/smatch/src/linearize.c

1548

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

1597

struct instruction *insn;

usr/src/tools/smatch/src/linearize.c

1603

insn = alloc_typed_instruction(OP_SEL, expr->ctype);

usr/src/tools/smatch/src/linearize.c

1606

use_pseudo(insn, cond, &insn->src1);

usr/src/tools/smatch/src/linearize.c

1607

use_pseudo(insn, valt, &insn->src2);

usr/src/tools/smatch/src/linearize.c

1608

use_pseudo(insn, valf, &insn->src3);

usr/src/tools/smatch/src/linearize.c

1610

res = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

1611

insn->target = res;

usr/src/tools/smatch/src/linearize.c

1612

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

2027

struct instruction *insn = alloc_instruction(OP_INLINED_CALL, 0);

usr/src/tools/smatch/src/linearize.c

2038

add_pseudo(&insn->arguments, value);

usr/src/tools/smatch/src/linearize.c

2043

insn->target = pseudo;

usr/src/tools/smatch/src/linearize.c

2045

use_pseudo(insn, symbol_pseudo(ep, stmt->inline_fn), &insn->func);

usr/src/tools/smatch/src/linearize.c

2049

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

2055

struct instruction *insn = alloc_instruction(OP_CONTEXT, 0);

usr/src/tools/smatch/src/linearize.c

2058

insn->increment = get_expression_value(expr);

usr/src/tools/smatch/src/linearize.c

2059

insn->context_expr = stmt->context;

usr/src/tools/smatch/src/linearize.c

2060

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

2066

struct instruction *insn = alloc_instruction(OP_RANGE, 0);

usr/src/tools/smatch/src/linearize.c

2068

use_pseudo(insn, linearize_expression(ep, stmt->range_expression), &insn->src1);

usr/src/tools/smatch/src/linearize.c

2069

use_pseudo(insn, linearize_expression(ep, stmt->range_low), &insn->src2);

usr/src/tools/smatch/src/linearize.c

2070

use_pseudo(insn, linearize_expression(ep, stmt->range_high), &insn->src3);

usr/src/tools/smatch/src/linearize.c

2071

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

2078

static void add_asm_input(struct entrypoint *ep, struct instruction *insn, struct expression *expr,

usr/src/tools/smatch/src/linearize.c

2086

use_pseudo(insn, pseudo, &rule->pseudo);

usr/src/tools/smatch/src/linearize.c

2087

add_ptr_list(&insn->asm_rules->inputs, rule);

usr/src/tools/smatch/src/linearize.c

2090

static void add_asm_output(struct entrypoint *ep, struct instruction *insn, struct expression *expr,

usr/src/tools/smatch/src/linearize.c

2094

pseudo_t pseudo = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

2103

use_pseudo(insn, pseudo, &rule->pseudo);

usr/src/tools/smatch/src/linearize.c

2104

add_ptr_list(&insn->asm_rules->outputs, rule);

usr/src/tools/smatch/src/linearize.c

2110

struct instruction *insn;

usr/src/tools/smatch/src/linearize.c

2114

insn = alloc_instruction(OP_ASM, 0);

usr/src/tools/smatch/src/linearize.c

2120

insn->string = expr->string->data;

usr/src/tools/smatch/src/linearize.c

2123

insn->asm_rules = rules;

usr/src/tools/smatch/src/linearize.c

2128

add_asm_input(ep, insn, expr->expr, constraint, expr->name);

usr/src/tools/smatch/src/linearize.c

2131

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.c

2136

add_asm_output(ep, insn, expr->expr, constraint, expr->name);

usr/src/tools/smatch/src/linearize.c

2163

static void sort_switch_cases(struct instruction *insn)

usr/src/tools/smatch/src/linearize.c

2165

sort_list((struct ptr_list **)&insn->multijmp_list, multijmp_cmp);

usr/src/tools/smatch/src/linearize.c

297

static char *show_asm(char *buf, struct instruction *insn)

usr/src/tools/smatch/src/linearize.c

299

struct asm_rules *rules = insn->asm_rules;

usr/src/tools/smatch/src/linearize.c

301

buf += sprintf(buf, "\"%s\"", insn->string);

usr/src/tools/smatch/src/linearize.c

308

const char *show_instruction(struct instruction *insn)

usr/src/tools/smatch/src/linearize.c

310

int opcode = insn->opcode;

usr/src/tools/smatch/src/linearize.c

315

if (!insn->bb)

usr/src/tools/smatch/src/linearize.c

324

if (insn->size)

usr/src/tools/smatch/src/linearize.c

325

buf += sprintf(buf, ".%d", insn->size);

usr/src/tools/smatch/src/linearize.c

334

if (insn->src && insn->src != VOID)

usr/src/tools/smatch/src/linearize.c

335

buf += sprintf(buf, "%s", show_pseudo(insn->src));

usr/src/tools/smatch/src/linearize.c

339

buf += sprintf(buf, "%s, %s, %s", show_pseudo(insn->cond), show_label(insn->bb_true), show_label(insn->bb_false));

usr/src/tools/smatch/src/linearize.c

343

buf += sprintf(buf, "%s", show_label(insn->bb_true));

usr/src/tools/smatch/src/linearize.c

347

struct expression *expr = insn->val;

usr/src/tools/smatch/src/linearize.c

348

buf += sprintf(buf, "%s <- ", show_pseudo(insn->target));

usr/src/tools/smatch/src/linearize.c

377

buf += sprintf(buf, "%s <- ", show_pseudo(insn->target));

usr/src/tools/smatch/src/linearize.c

378

buf += sprintf(buf, "%Le", insn->fvalue);

usr/src/tools/smatch/src/linearize.c

383

buf += sprintf(buf, "%s", show_pseudo(insn->cond));

usr/src/tools/smatch/src/linearize.c

384

FOR_EACH_PTR(insn->multijmp_list, jmp) {

usr/src/tools/smatch/src/linearize.c

396

buf += sprintf(buf, "%s", show_pseudo(insn->src));

usr/src/tools/smatch/src/linearize.c

397

FOR_EACH_PTR(insn->multijmp_list, jmp) {

usr/src/tools/smatch/src/linearize.c

405

buf += sprintf(buf, "%s <- %s ", show_pseudo(insn->target), show_pseudo(insn->phi_src));

usr/src/tools/smatch/src/linearize.c

406

FOR_EACH_PTR(insn->phi_users, phi) {

usr/src/tools/smatch/src/linearize.c

415

buf += sprintf(buf, "%s", show_pseudo(insn->target));

usr/src/tools/smatch/src/linearize.c

416

FOR_EACH_PTR(insn->phi_list, phi) {

usr/src/tools/smatch/src/linearize.c

425

buf += sprintf(buf, "%s <- %d[%s]", show_pseudo(insn->target), insn->offset, show_pseudo(insn->src));

usr/src/tools/smatch/src/linearize.c

428

buf += sprintf(buf, "%s -> %d[%s]", show_pseudo(insn->target), insn->offset, show_pseudo(insn->src));

usr/src/tools/smatch/src/linearize.c

433

if (insn->target && insn->target != VOID)

usr/src/tools/smatch/src/linearize.c

434

buf += sprintf(buf, "%s <- ", show_pseudo(insn->target));

usr/src/tools/smatch/src/linearize.c

435

buf += sprintf(buf, "%s", show_pseudo(insn->func));

usr/src/tools/smatch/src/linearize.c

436

FOR_EACH_PTR(insn->arguments, arg) {

usr/src/tools/smatch/src/linearize.c

450

show_pseudo(insn->target),

usr/src/tools/smatch/src/linearize.c

451

type_size(insn->orig_type),

usr/src/tools/smatch/src/linearize.c

452

show_pseudo(insn->src));

usr/src/tools/smatch/src/linearize.c

457

buf += sprintf(buf, "%s <- %s, %s", show_pseudo(insn->target), show_pseudo(insn->src1), show_pseudo(insn->src2));

usr/src/tools/smatch/src/linearize.c

461

buf += sprintf(buf, "%s <- %s, %s, %s", show_pseudo(insn->target),

usr/src/tools/smatch/src/linearize.c

462

show_pseudo(insn->src1), show_pseudo(insn->src2), show_pseudo(insn->src3));

usr/src/tools/smatch/src/linearize.c

466

buf += sprintf(buf, "%s <- %s, %d, %d", show_pseudo(insn->target), show_pseudo(insn->base), insn->from, insn->len);

usr/src/tools/smatch/src/linearize.c

47

struct instruction * insn = __alloc_instruction(0);

usr/src/tools/smatch/src/linearize.c

472

buf += sprintf(buf, "%s <- %s", show_pseudo(insn->target), show_pseudo(insn->src1));

usr/src/tools/smatch/src/linearize.c

476

buf += sprintf(buf, "%s%d", insn->check ? "check: " : "", insn->increment);

usr/src/tools/smatch/src/linearize.c

479

buf += sprintf(buf, "%s between %s..%s", show_pseudo(insn->src1), show_pseudo(insn->src2), show_pseudo(insn->src3));

usr/src/tools/smatch/src/linearize.c

48

insn->opcode = opcode;

usr/src/tools/smatch/src/linearize.c

482

buf += sprintf(buf, "%s <- %s", show_pseudo(insn->target), show_pseudo(insn->src1));

usr/src/tools/smatch/src/linearize.c

485

buf += sprintf(buf, "%s", show_pseudo(insn->target));

usr/src/tools/smatch/src/linearize.c

488

buf = show_asm(buf, insn);

usr/src/tools/smatch/src/linearize.c

49

insn->size = size;

usr/src/tools/smatch/src/linearize.c

491

buf += sprintf(buf, "%s <- %s", show_pseudo(insn->target), show_pseudo(insn->src));

usr/src/tools/smatch/src/linearize.c

50

insn->pos = current_pos;

usr/src/tools/smatch/src/linearize.c

506

struct instruction *insn;

usr/src/tools/smatch/src/linearize.c

51

return insn;

usr/src/tools/smatch/src/linearize.c

552

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/linearize.c

553

if (!insn->bb && verbose < 2)

usr/src/tools/smatch/src/linearize.c

555

printf("\t%s\n", show_instruction(insn));

usr/src/tools/smatch/src/linearize.c

556

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/linearize.c

567

printf("\t%s\n", show_instruction(pu->insn));

usr/src/tools/smatch/src/linearize.c

61

struct instruction *insn = alloc_instruction(opcode, type_size(type));

usr/src/tools/smatch/src/linearize.c

62

insn->type = type;

usr/src/tools/smatch/src/linearize.c

63

return insn;

usr/src/tools/smatch/src/linearize.c

647

static void add_one_insn(struct entrypoint *ep, struct instruction *insn)

usr/src/tools/smatch/src/linearize.c

652

insn->bb = bb;

usr/src/tools/smatch/src/linearize.c

653

add_instruction(&bb->insns, insn);

usr/src/tools/smatch/src/linearize.c

845

struct instruction *insn = alloc_typed_instruction(OP_PHISOURCE, type);

usr/src/tools/smatch/src/linearize.c

851

phi->def = insn;

usr/src/tools/smatch/src/linearize.c

853

use_pseudo(insn, pseudo, &insn->phi_src);

usr/src/tools/smatch/src/linearize.c

854

insn->target = phi;

usr/src/tools/smatch/src/linearize.c

855

return insn;

usr/src/tools/smatch/src/linearize.c

860

struct instruction *insn;

usr/src/tools/smatch/src/linearize.c

865

insn = alloc_phisrc(pseudo, type);

usr/src/tools/smatch/src/linearize.c

866

insn->bb = source;

usr/src/tools/smatch/src/linearize.c

867

add_instruction(&source->insns, insn);

usr/src/tools/smatch/src/linearize.c

868

return insn->target;

usr/src/tools/smatch/src/linearize.c

886

struct instruction *insn;

usr/src/tools/smatch/src/linearize.c

888

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/linearize.c

889

enum opcode op = insn->opcode;

usr/src/tools/smatch/src/linearize.c

892

INSERT_CURRENT(phi_node, insn);

usr/src/tools/smatch/src/linearize.c

894

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/linearize.c

971

struct instruction *insn;

usr/src/tools/smatch/src/linearize.c

977

insn = alloc_typed_instruction(OP_LOAD, ad->btype);

usr/src/tools/smatch/src/linearize.c

978

new = alloc_pseudo(insn);

usr/src/tools/smatch/src/linearize.c

980

insn->target = new;

usr/src/tools/smatch/src/linearize.c

981

insn->offset = ad->offset;

usr/src/tools/smatch/src/linearize.c

982

insn->is_volatile = ad->type && (ad->type->ctype.modifiers & MOD_VOLATILE);

usr/src/tools/smatch/src/linearize.c

983

use_pseudo(insn, ad->address, &insn->src);

usr/src/tools/smatch/src/linearize.c

984

add_one_insn(ep, insn);

usr/src/tools/smatch/src/linearize.h

15

struct instruction *insn;

usr/src/tools/smatch/src/linearize.h

191

static inline void add_instruction(struct instruction_list **list, struct instruction *insn)

usr/src/tools/smatch/src/linearize.h

193

add_ptr_list(list, insn);

usr/src/tools/smatch/src/linearize.h

218

struct instruction *insn;

usr/src/tools/smatch/src/linearize.h

221

insn = last_instruction(bb->insns);

usr/src/tools/smatch/src/linearize.h

222

return insn && insn->opcode >= OP_TERMINATOR

usr/src/tools/smatch/src/linearize.h

223

&& insn->opcode <= OP_TERMINATOR_END;

usr/src/tools/smatch/src/linearize.h

272

static inline struct pseudo_user *alloc_pseudo_user(struct instruction *insn, pseudo_t *pp)

usr/src/tools/smatch/src/linearize.h

276

user->insn = insn;

usr/src/tools/smatch/src/linearize.h

280

static inline void use_pseudo(struct instruction *insn, pseudo_t p, pseudo_t *pp)

usr/src/tools/smatch/src/linearize.h

284

add_pseudo_user_ptr(alloc_pseudo_user(insn, pp), &p->users);

usr/src/tools/smatch/src/linearize.h

326

const char *show_instruction(struct instruction *insn);

usr/src/tools/smatch/src/liveness.c

100

phi_defines(insn, insn->target, def);

usr/src/tools/smatch/src/liveness.c

113

if (insn->target != VOID)

usr/src/tools/smatch/src/liveness.c

115

FOR_EACH_PTR(insn->arguments, pseudo) {

usr/src/tools/smatch/src/liveness.c

125

asm_liveness(bb, insn, def, use);

usr/src/tools/smatch/src/liveness.c

208

struct instruction *insn;

usr/src/tools/smatch/src/liveness.c

209

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/liveness.c

210

if (!insn->bb)

usr/src/tools/smatch/src/liveness.c

212

assert(insn->bb == bb);

usr/src/tools/smatch/src/liveness.c

213

track_instruction_usage(bb, insn, insn_defines, insn_uses);

usr/src/tools/smatch/src/liveness.c

214

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/liveness.c

250

static void track_phi_uses(struct instruction *insn)

usr/src/tools/smatch/src/liveness.c

253

FOR_EACH_PTR(insn->phi_list, phi) {

usr/src/tools/smatch/src/liveness.c

259

add_ptr_list(&def->phi_users, insn);

usr/src/tools/smatch/src/liveness.c

265

struct instruction *insn;

usr/src/tools/smatch/src/liveness.c

266

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/liveness.c

267

if (insn->bb && insn->opcode == OP_PHI)

usr/src/tools/smatch/src/liveness.c

268

track_phi_uses(insn);

usr/src/tools/smatch/src/liveness.c

269

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/liveness.c

291

struct instruction *insn;

usr/src/tools/smatch/src/liveness.c

298

FOR_EACH_PTR_REVERSE(bb->insns, insn) {

usr/src/tools/smatch/src/liveness.c

299

if (!insn->bb)

usr/src/tools/smatch/src/liveness.c

303

track_instruction_usage(bb, insn, death_def, death_use);

usr/src/tools/smatch/src/liveness.c

31

static void asm_liveness(struct basic_block *bb, struct instruction *insn,

usr/src/tools/smatch/src/liveness.c

311

INSERT_CURRENT(deathnote, insn);

usr/src/tools/smatch/src/liveness.c

315

} END_FOR_EACH_PTR_REVERSE(insn);

usr/src/tools/smatch/src/liveness.c

37

FOR_EACH_PTR(insn->asm_rules->inputs, entry) {

usr/src/tools/smatch/src/liveness.c

41

FOR_EACH_PTR(insn->asm_rules->outputs, entry) {

usr/src/tools/smatch/src/liveness.c

46

static void track_instruction_usage(struct basic_block *bb, struct instruction *insn,

usr/src/tools/smatch/src/liveness.c

52

#define USES(x) use(bb, insn->x)

usr/src/tools/smatch/src/liveness.c

53

#define DEFINES(x) def(bb, insn->x)

usr/src/tools/smatch/src/liveness.c

55

switch (insn->opcode) {

usr/src/tools/smatch/src/memops.c

100

check_access(insn);

usr/src/tools/smatch/src/memops.c

102

if (insn->is_volatile)

usr/src/tools/smatch/src/memops.c

105

RECURSE_PTR_REVERSE(insn, dom) {

usr/src/tools/smatch/src/memops.c

109

dominance = dominates(pseudo, insn, dom, local);

usr/src/tools/smatch/src/memops.c

118

convert_load_instruction(insn, dom->target);

usr/src/tools/smatch/src/memops.c

127

if (find_dominating_parents(pseudo, insn, bb, generation, &dominators, local)) {

usr/src/tools/smatch/src/memops.c

132

convert_load_instruction(insn, value_pseudo(0));

usr/src/tools/smatch/src/memops.c

136

rewrite_load_instruction(insn, dominators);

usr/src/tools/smatch/src/memops.c

146

} END_FOR_EACH_PTR_REVERSE(insn);

usr/src/tools/smatch/src/memops.c

151

struct instruction *insn;

usr/src/tools/smatch/src/memops.c

153

FOR_EACH_PTR_REVERSE(bb->insns, insn) {

usr/src/tools/smatch/src/memops.c

154

if (!insn->bb)

usr/src/tools/smatch/src/memops.c

156

if (insn->opcode == OP_STORE) {

usr/src/tools/smatch/src/memops.c

158

pseudo_t pseudo = insn->src;

usr/src/tools/smatch/src/memops.c

161

if (!insn->type)

usr/src/tools/smatch/src/memops.c

163

if (insn->is_volatile)

usr/src/tools/smatch/src/memops.c

167

RECURSE_PTR_REVERSE(insn, dom) {

usr/src/tools/smatch/src/memops.c

171

dominance = dominates(pseudo, insn, dom, local);

usr/src/tools/smatch/src/memops.c

187

} END_FOR_EACH_PTR_REVERSE(insn);

usr/src/tools/smatch/src/memops.c

19

static int find_dominating_parents(pseudo_t pseudo, struct instruction *insn,

usr/src/tools/smatch/src/memops.c

34

if (one == insn)

usr/src/tools/smatch/src/memops.c

36

dominance = dominates(pseudo, insn, one, local);

usr/src/tools/smatch/src/memops.c

51

if (!find_dominating_parents(pseudo, insn, parent, generation, dominators, local))

usr/src/tools/smatch/src/memops.c

60

use_pseudo(insn, phi, add_pseudo(dominators, phi));

usr/src/tools/smatch/src/memops.c

69

struct instruction *insn = pu->insn;

usr/src/tools/smatch/src/memops.c

70

if (insn->bb && (insn->opcode != OP_LOAD && insn->opcode != OP_STORE))

usr/src/tools/smatch/src/memops.c

72

if (pu->userp != &insn->src)

usr/src/tools/smatch/src/memops.c

87

struct instruction *insn;

usr/src/tools/smatch/src/memops.c

89

FOR_EACH_PTR_REVERSE(bb->insns, insn) {

usr/src/tools/smatch/src/memops.c

90

if (!insn->bb)

usr/src/tools/smatch/src/memops.c

92

if (insn->opcode == OP_LOAD) {

usr/src/tools/smatch/src/memops.c

94

pseudo_t pseudo = insn->src;

usr/src/tools/smatch/src/optimize.c

35

struct instruction *insn;

usr/src/tools/smatch/src/optimize.c

36

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/optimize.c

37

repeat_phase |= simplify_instruction(insn);

usr/src/tools/smatch/src/optimize.c

38

if (!insn->bb)

usr/src/tools/smatch/src/optimize.c

40

assert(insn->bb == bb);

usr/src/tools/smatch/src/optimize.c

41

cse_collect(insn);

usr/src/tools/smatch/src/optimize.c

42

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/simplify.c

1000

insn->opcode = inverse ? opcode_table[opcode].negate : opcode;

usr/src/tools/smatch/src/simplify.c

1001

use_pseudo(insn, def->src1, &insn->src1);

usr/src/tools/smatch/src/simplify.c

1002

use_pseudo(insn, def->src2, &insn->src2);

usr/src/tools/smatch/src/simplify.c

1003

remove_usage(old, &insn->src1);

usr/src/tools/smatch/src/simplify.c

1017

return replace_pseudo(insn, &insn->src1, def->src);

usr/src/tools/smatch/src/simplify.c

1038

static int simplify_constant_mask(struct instruction *insn, unsigned long long mask)

usr/src/tools/smatch/src/simplify.c

1040

pseudo_t old = insn->src1;

usr/src/tools/smatch/src/simplify.c

105

bb = insn->bb;

usr/src/tools/smatch/src/simplify.c

1051

return simplify_mask_or(insn, mask, def);

usr/src/tools/smatch/src/simplify.c

106

if (get_phisources(array, 2, insn))

usr/src/tools/smatch/src/simplify.c

1063

return replace_with_pseudo(insn, old);

usr/src/tools/smatch/src/simplify.c

1066

insn->src2 = value_pseudo(nmask);

usr/src/tools/smatch/src/simplify.c

1074

static int simplify_constant_rightside(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1076

long long value = insn->src2->value;

usr/src/tools/smatch/src/simplify.c

1077

long long sbit = 1ULL << (insn->size - 1);

usr/src/tools/smatch/src/simplify.c

1080

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1083

return replace_with_pseudo(insn, insn->src2);

usr/src/tools/smatch/src/simplify.c

1088

insn->opcode = OP_NOT;

usr/src/tools/smatch/src/simplify.c

1095

insn->opcode = OP_ADD;

usr/src/tools/smatch/src/simplify.c

1096

insn->src2 = value_pseudo(-value);

usr/src/tools/smatch/src/simplify.c

1103

return replace_with_pseudo(insn, insn->src1);

usr/src/tools/smatch/src/simplify.c

1108

return simplify_shift(insn, insn->src1, value);

usr/src/tools/smatch/src/simplify.c

1112

return replace_with_pseudo(insn, value_pseudo(0));

usr/src/tools/smatch/src/simplify.c

1117

return simplify_mul_div(insn, value);

usr/src/tools/smatch/src/simplify.c

1121

return replace_with_pseudo(insn, insn->src2);

usr/src/tools/smatch/src/simplify.c

1123

return replace_with_pseudo(insn, insn->src1);

usr/src/tools/smatch/src/simplify.c

1124

return simplify_constant_mask(insn, value);

usr/src/tools/smatch/src/simplify.c

1128

return simplify_seteq_setne(insn, value);

usr/src/tools/smatch/src/simplify.c

1133

static int simplify_constant_leftside(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1135

long long value = insn->src1->value;

usr/src/tools/smatch/src/simplify.c

1137

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1140

return replace_with_pseudo(insn, insn->src2);

usr/src/tools/smatch/src/simplify.c

1148

return replace_with_pseudo(insn, insn->src1);

usr/src/tools/smatch/src/simplify.c

1154

static int simplify_constant_binop(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1156

pseudo_t res = eval_insn(insn);

usr/src/tools/smatch/src/simplify.c

1161

replace_with_pseudo(insn, res);

usr/src/tools/smatch/src/simplify.c

1165

static int simplify_binop_same_args(struct instruction *insn, pseudo_t arg)

usr/src/tools/smatch/src/simplify.c

1167

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1172

warning(insn->pos, "self-comparison always evaluates to false");

usr/src/tools/smatch/src/simplify.c

1175

return replace_with_pseudo(insn, value_pseudo(0));

usr/src/tools/smatch/src/simplify.c

1181

warning(insn->pos, "self-comparison always evaluates to true");

usr/src/tools/smatch/src/simplify.c

1182

return replace_with_pseudo(insn, value_pseudo(1));

usr/src/tools/smatch/src/simplify.c

1186

return replace_with_pseudo(insn, arg);

usr/src/tools/smatch/src/simplify.c

1195

static int simplify_binop(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1197

if (dead_insn(insn, &insn->src1, &insn->src2, NULL))

usr/src/tools/smatch/src/simplify.c

1199

if (constant(insn->src1)) {

usr/src/tools/smatch/src/simplify.c

1200

if (constant(insn->src2))

usr/src/tools/smatch/src/simplify.c

1201

return simplify_constant_binop(insn);

usr/src/tools/smatch/src/simplify.c

1202

return simplify_constant_leftside(insn);

usr/src/tools/smatch/src/simplify.c

1204

if (constant(insn->src2))

usr/src/tools/smatch/src/simplify.c

1205

return simplify_constant_rightside(insn);

usr/src/tools/smatch/src/simplify.c

1206

if (insn->src1 == insn->src2)

usr/src/tools/smatch/src/simplify.c

1207

return simplify_binop_same_args(insn, insn->src1);

usr/src/tools/smatch/src/simplify.c

1233

static int canonicalize_commutative(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1235

if (canonical_order(insn->src1, insn->src2))

usr/src/tools/smatch/src/simplify.c

1238

switch_pseudo(insn, &insn->src1, insn, &insn->src2);

usr/src/tools/smatch/src/simplify.c

1242

static int canonicalize_compare(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1244

if (canonical_order(insn->src1, insn->src2))

usr/src/tools/smatch/src/simplify.c

1247

switch_pseudo(insn, &insn->src1, insn, &insn->src2);

usr/src/tools/smatch/src/simplify.c

1248

insn->opcode = opcode_table[insn->opcode].swap;

usr/src/tools/smatch/src/simplify.c

1257

static int simplify_associative_binop(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1260

pseudo_t pseudo = insn->src1;

usr/src/tools/smatch/src/simplify.c

1262

if (!simple_pseudo(insn->src2))

usr/src/tools/smatch/src/simplify.c

1267

if (def == insn)

usr/src/tools/smatch/src/simplify.c

1269

if (def->opcode != insn->opcode)

usr/src/tools/smatch/src/simplify.c

1275

switch_pseudo(def, &def->src1, insn, &insn->src2);

usr/src/tools/smatch/src/simplify.c

1279

static int simplify_constant_unop(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1281

long long val = insn->src1->value;

usr/src/tools/smatch/src/simplify.c

1284

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1292

mask = 1ULL << (insn->orig_type->bit_size-1);

usr/src/tools/smatch/src/simplify.c

1303

mask = 1ULL << (insn->size-1);

usr/src/tools/smatch/src/simplify.c

1306

replace_with_pseudo(insn, value_pseudo(res));

usr/src/tools/smatch/src/simplify.c

1310

static int simplify_unop(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1312

if (dead_insn(insn, &insn->src1, NULL, NULL))

usr/src/tools/smatch/src/simplify.c

1314

if (constant(insn->src1))

usr/src/tools/smatch/src/simplify.c

1315

return simplify_constant_unop(insn);

usr/src/tools/smatch/src/simplify.c

1317

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1321

def = insn->src->def;

usr/src/tools/smatch/src/simplify.c

1323

return replace_with_pseudo(insn, def->src);

usr/src/tools/smatch/src/simplify.c

1326

def = insn->src->def;

usr/src/tools/smatch/src/simplify.c

1328

return replace_with_pseudo(insn, def->src);

usr/src/tools/smatch/src/simplify.c

1336

static int simplify_one_memop(struct instruction *insn, pseudo_t orig)

usr/src/tools/smatch/src/simplify.c

1338

pseudo_t addr = insn->src;

usr/src/tools/smatch/src/simplify.c

1344

kill_use(&insn->src);

usr/src/tools/smatch/src/simplify.c

1345

use_pseudo(insn, def->src, &insn->src);

usr/src/tools/smatch/src/simplify.c

1376

warning(insn->pos, "crazy programmer");

usr/src/tools/smatch/src/simplify.c

1377

replace_pseudo(insn, &insn->src, VOID);

usr/src/tools/smatch/src/simplify.c

1380

insn->offset += off->value;

usr/src/tools/smatch/src/simplify.c

1381

replace_pseudo(insn, &insn->src, new);

usr/src/tools/smatch/src/simplify.c

1390

static int simplify_memop(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1393

pseudo_t orig = insn->src;

usr/src/tools/smatch/src/simplify.c

1396

one = simplify_one_memop(insn, orig);

usr/src/tools/smatch/src/simplify.c

1402

static int simplify_cast(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1411

if (dead_insn(insn, &insn->src, NULL, NULL))

usr/src/tools/smatch/src/simplify.c

1414

src = insn->src;

usr/src/tools/smatch/src/simplify.c

1418

return simplify_constant_unop(insn);

usr/src/tools/smatch/src/simplify.c

1421

size = insn->size;

usr/src/tools/smatch/src/simplify.c

1429

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1435

def->type = insn->type;

usr/src/tools/smatch/src/simplify.c

1438

insn->opcode = OP_AND;

usr/src/tools/smatch/src/simplify.c

1441

insn->src2 = value_pseudo(mask);

usr/src/tools/smatch/src/simplify.c

1461

def->orig_type = insn->orig_type;

usr/src/tools/smatch/src/simplify.c

1462

def->type = insn->type;

usr/src/tools/smatch/src/simplify.c

1463

def->size = insn->size;

usr/src/tools/smatch/src/simplify.c

1464

insn->opcode = OP_AND;

usr/src/tools/smatch/src/simplify.c

1465

insn->src2 = val;

usr/src/tools/smatch/src/simplify.c

1470

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1472

if (insn->size == 1)

usr/src/tools/smatch/src/simplify.c

1483

insn->opcode = def->opcode;

usr/src/tools/smatch/src/simplify.c

1484

use_pseudo(insn, def->src2, &insn->src2);

usr/src/tools/smatch/src/simplify.c

1485

return replace_pseudo(insn, &insn->src1, def->src1);

usr/src/tools/smatch/src/simplify.c

1489

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1491

mask = bits_mask(insn->size);

usr/src/tools/smatch/src/simplify.c

1492

return simplify_mask_or(insn, mask, def);

usr/src/tools/smatch/src/simplify.c

1497

if (insn->opcode != OP_TRUNC)

usr/src/tools/smatch/src/simplify.c

1499

mask = bits_mask(insn->size);

usr/src/tools/smatch/src/simplify.c

1502

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1504

insn->orig_type = def->orig_type;

usr/src/tools/smatch/src/simplify.c

1505

return replace_pseudo(insn, &insn->src1, def->src);

usr/src/tools/smatch/src/simplify.c

1509

insn->opcode = OP_AND;

usr/src/tools/smatch/src/simplify.c

1510

insn->src2 = value_pseudo((1ULL << def->size) - 1);

usr/src/tools/smatch/src/simplify.c

1511

return replace_pseudo(insn, &insn->src1, def->src);

usr/src/tools/smatch/src/simplify.c

1515

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1517

insn->opcode = OP_ZEXT;

usr/src/tools/smatch/src/simplify.c

1520

insn->orig_type = def->orig_type;

usr/src/tools/smatch/src/simplify.c

1521

return replace_pseudo(insn, &insn->src, def->src);

usr/src/tools/smatch/src/simplify.c

1525

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1529

return replace_with_pseudo(insn, def->src);

usr/src/tools/smatch/src/simplify.c

1531

insn->opcode = def->opcode;

usr/src/tools/smatch/src/simplify.c

1532

insn->orig_type = def->orig_type;

usr/src/tools/smatch/src/simplify.c

1533

return replace_pseudo(insn, &insn->src, def->src);

usr/src/tools/smatch/src/simplify.c

1535

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1537

insn->orig_type = def->orig_type;

usr/src/tools/smatch/src/simplify.c

1538

return replace_pseudo(insn, &insn->src, def->src);

usr/src/tools/smatch/src/simplify.c

1546

static int simplify_select(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1550

if (dead_insn(insn, &insn->src1, &insn->src2, &insn->src3))

usr/src/tools/smatch/src/simplify.c

1553

cond = insn->src1;

usr/src/tools/smatch/src/simplify.c

1554

src1 = insn->src2;

usr/src/tools/smatch/src/simplify.c

1555

src2 = insn->src3;

usr/src/tools/smatch/src/simplify.c

1558

kill_use(&insn->src1);

usr/src/tools/smatch/src/simplify.c

1560

kill = cond->value ? &insn->src3 : &insn->src2;

usr/src/tools/smatch/src/simplify.c

1562

replace_with_pseudo(insn, take);

usr/src/tools/smatch/src/simplify.c

1576

insn->opcode = opcode;

usr/src/tools/smatch/src/simplify.c

1578

insn->src2 = src1; /* Zero */

usr/src/tools/smatch/src/simplify.c

1583

kill_use(&insn->src1);

usr/src/tools/smatch/src/simplify.c

1584

kill_use(&insn->src3);

usr/src/tools/smatch/src/simplify.c

1585

replace_with_pseudo(insn, value_pseudo(0));

usr/src/tools/smatch/src/simplify.c

1604

static int simplify_range(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1608

src1 = insn->src1;

usr/src/tools/smatch/src/simplify.c

1609

src2 = insn->src2;

usr/src/tools/smatch/src/simplify.c

1610

src3 = insn->src3;

usr/src/tools/smatch/src/simplify.c

1614

kill_instruction(insn);

usr/src/tools/smatch/src/simplify.c

1633

static int simplify_branch(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1635

pseudo_t cond = insn->cond;

usr/src/tools/smatch/src/simplify.c

1639

insert_branch(insn->bb, insn, cond->value ? insn->bb_true : insn->bb_false);

usr/src/tools/smatch/src/simplify.c

1644

if (insn->bb_true == insn->bb_false) {

usr/src/tools/smatch/src/simplify.c

1645

struct basic_block *bb = insn->bb;

usr/src/tools/smatch/src/simplify.c

1646

struct basic_block *target = insn->bb_false;

usr/src/tools/smatch/src/simplify.c

1649

insn->bb_false = NULL;

usr/src/tools/smatch/src/simplify.c

1650

kill_use(&insn->cond);

usr/src/tools/smatch/src/simplify.c

1651

insn->cond = NULL;

usr/src/tools/smatch/src/simplify.c

1652

insn->opcode = OP_BR;

usr/src/tools/smatch/src/simplify.c

1662

return simplify_cond_branch(insn, def, def->src2);

usr/src/tools/smatch/src/simplify.c

1664

return simplify_cond_branch(insn, def, def->src1);

usr/src/tools/smatch/src/simplify.c

1671

insert_branch(insn->bb, insn, insn->bb_false);

usr/src/tools/smatch/src/simplify.c

1675

insert_branch(insn->bb, insn, insn->bb_true);

usr/src/tools/smatch/src/simplify.c

1679

struct basic_block *tmp = insn->bb_true;

usr/src/tools/smatch/src/simplify.c

1680

insn->bb_true = insn->bb_false;

usr/src/tools/smatch/src/simplify.c

1681

insn->bb_false = tmp;

usr/src/tools/smatch/src/simplify.c

1683

return replace_pseudo(insn, &insn->cond, def->src1);

usr/src/tools/smatch/src/simplify.c

1687

return replace_pseudo(insn, &insn->cond, def->src);

usr/src/tools/smatch/src/simplify.c

1692

static int simplify_switch(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1694

pseudo_t cond = insn->cond;

usr/src/tools/smatch/src/simplify.c

170

insert_select(source, br, insn, p1, p2);

usr/src/tools/smatch/src/simplify.c

1700

val = insn->cond->value;

usr/src/tools/smatch/src/simplify.c

1702

FOR_EACH_PTR(insn->multijmp_list, jmp) {

usr/src/tools/smatch/src/simplify.c

1709

warning(insn->pos, "Impossible case statement");

usr/src/tools/smatch/src/simplify.c

171

kill_instruction(insn);

usr/src/tools/smatch/src/simplify.c

1713

insert_branch(insn->bb, insn, jmp->target);

usr/src/tools/smatch/src/simplify.c

1717

int simplify_instruction(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

1719

if (!insn->bb)

usr/src/tools/smatch/src/simplify.c

1721

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

1724

canonicalize_commutative(insn);

usr/src/tools/smatch/src/simplify.c

1725

if (simplify_binop(insn))

usr/src/tools/smatch/src/simplify.c

1727

return simplify_associative_binop(insn);

usr/src/tools/smatch/src/simplify.c

1730

canonicalize_commutative(insn);

usr/src/tools/smatch/src/simplify.c

1731

return simplify_binop(insn);

usr/src/tools/smatch/src/simplify.c

1737

canonicalize_compare(insn);

usr/src/tools/smatch/src/simplify.c

1744

return simplify_binop(insn);

usr/src/tools/smatch/src/simplify.c

1747

return simplify_unop(insn);

usr/src/tools/smatch/src/simplify.c

1749

if (!has_users(insn->target))

usr/src/tools/smatch/src/simplify.c

1750

return kill_instruction(insn);

usr/src/tools/smatch/src/simplify.c

1753

return simplify_memop(insn);

usr/src/tools/smatch/src/simplify.c

1755

if (dead_insn(insn, &insn->src, NULL, NULL))

usr/src/tools/smatch/src/simplify.c

1757

return replace_with_pseudo(insn, insn->src);

usr/src/tools/smatch/src/simplify.c

1760

return simplify_cast(insn);

usr/src/tools/smatch/src/simplify.c

1765

if (dead_insn(insn, &insn->src, NULL, NULL))

usr/src/tools/smatch/src/simplify.c

1770

return replace_with_pseudo(insn, insn->src);

usr/src/tools/smatch/src/simplify.c

1772

if (dead_insn(insn, &insn->src, NULL, NULL))

usr/src/tools/smatch/src/simplify.c

1777

if (dead_insn(insn, NULL, NULL, NULL))

usr/src/tools/smatch/src/simplify.c

1781

if (dead_insn(insn, NULL, NULL, NULL)) {

usr/src/tools/smatch/src/simplify.c

1782

kill_use_list(insn->phi_list);

usr/src/tools/smatch/src/simplify.c

1785

return clean_up_phi(insn);

usr/src/tools/smatch/src/simplify.c

1787

if (dead_insn(insn, &insn->phi_src, NULL, NULL))

usr/src/tools/smatch/src/simplify.c

1791

return simplify_select(insn);

usr/src/tools/smatch/src/simplify.c

1793

return simplify_branch(insn);

usr/src/tools/smatch/src/simplify.c

1795

return simplify_switch(insn);

usr/src/tools/smatch/src/simplify.c

1797

return simplify_range(insn);

usr/src/tools/smatch/src/simplify.c

1802

if (dead_insn(insn, &insn->src1, &insn->src2, NULL))

usr/src/tools/smatch/src/simplify.c

188

static pseudo_t trivial_phi(pseudo_t pseudo, struct instruction *insn, struct pseudo_list **list)

usr/src/tools/smatch/src/simplify.c

190

pseudo_t target = insn->target;

usr/src/tools/smatch/src/simplify.c

195

FOR_EACH_PTR(insn->phi_list, phi) {

usr/src/tools/smatch/src/simplify.c

227

static int clean_up_phi(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

232

if ((pseudo = trivial_phi(NULL, insn, &list))) {

usr/src/tools/smatch/src/simplify.c

233

convert_instruction_target(insn, pseudo);

usr/src/tools/smatch/src/simplify.c

234

kill_instruction(insn);

usr/src/tools/smatch/src/simplify.c

238

return if_convert_phi(insn);

usr/src/tools/smatch/src/simplify.c

312

int kill_insn(struct instruction *insn, int force)

usr/src/tools/smatch/src/simplify.c

314

if (!insn || !insn->bb)

usr/src/tools/smatch/src/simplify.c

317

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

320

kill_use(&insn->src3);

usr/src/tools/smatch/src/simplify.c

324

kill_use(&insn->src2);

usr/src/tools/smatch/src/simplify.c

330

kill_use(&insn->src1);

usr/src/tools/smatch/src/simplify.c

334

kill_use_list(insn->phi_list);

usr/src/tools/smatch/src/simplify.c

337

kill_use(&insn->phi_src);

usr/src/tools/smatch/src/simplify.c

341

kill_use(&insn->src);

usr/src/tools/smatch/src/simplify.c

348

kill_use(&insn->cond);

usr/src/tools/smatch/src/simplify.c

354

if (!(insn->func->type == PSEUDO_SYM))

usr/src/tools/smatch/src/simplify.c

356

if (!(insn->func->sym->ctype.modifiers & MOD_PURE))

usr/src/tools/smatch/src/simplify.c

359

kill_use_list(insn->arguments);

usr/src/tools/smatch/src/simplify.c

360

if (insn->func->type == PSEUDO_REG)

usr/src/tools/smatch/src/simplify.c

361

kill_use(&insn->func);

usr/src/tools/smatch/src/simplify.c

365

if (!force && insn->is_volatile)

usr/src/tools/smatch/src/simplify.c

367

kill_use(&insn->src);

usr/src/tools/smatch/src/simplify.c

373

kill_use(&insn->src);

usr/src/tools/smatch/src/simplify.c

374

kill_use(&insn->target);

usr/src/tools/smatch/src/simplify.c

387

insn->bb = NULL;

usr/src/tools/smatch/src/simplify.c

393

static int dead_insn(struct instruction *insn, pseudo_t *src1, pseudo_t *src2, pseudo_t *src3)

usr/src/tools/smatch/src/simplify.c

395

if (has_users(insn->target))

usr/src/tools/smatch/src/simplify.c

398

insn->bb = NULL;

usr/src/tools/smatch/src/simplify.c

405

static inline bool has_target(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

407

return opcode_table[insn->opcode].flags & OPF_TARGET;

usr/src/tools/smatch/src/simplify.c

415

struct instruction *insn;

usr/src/tools/smatch/src/simplify.c

416

FOR_EACH_PTR_REVERSE(bb->insns, insn) {

usr/src/tools/smatch/src/simplify.c

417

if (!insn->bb)

usr/src/tools/smatch/src/simplify.c

419

if (!has_target(insn))

usr/src/tools/smatch/src/simplify.c

421

if (!has_users(insn->target))

usr/src/tools/smatch/src/simplify.c

422

kill_instruction(insn);

usr/src/tools/smatch/src/simplify.c

423

} END_FOR_EACH_PTR_REVERSE(insn);

usr/src/tools/smatch/src/simplify.c

438

static inline int replace_pseudo(struct instruction *insn, pseudo_t *pp, pseudo_t new)

usr/src/tools/smatch/src/simplify.c

441

use_pseudo(insn, new, pp);

usr/src/tools/smatch/src/simplify.c

446

static int replace_with_pseudo(struct instruction *insn, pseudo_t pseudo)

usr/src/tools/smatch/src/simplify.c

448

convert_instruction_target(insn, pseudo);

usr/src/tools/smatch/src/simplify.c

450

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

453

kill_use(&insn->src3);

usr/src/tools/smatch/src/simplify.c

455

kill_use(&insn->src2);

usr/src/tools/smatch/src/simplify.c

458

kill_use(&insn->src1);

usr/src/tools/smatch/src/simplify.c

464

insn->bb = NULL;

usr/src/tools/smatch/src/simplify.c

494

static unsigned int operand_size(struct instruction *insn, pseudo_t pseudo)

usr/src/tools/smatch/src/simplify.c

496

unsigned int size = insn->size;

usr/src/tools/smatch/src/simplify.c

514

static pseudo_t eval_insn(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

517

unsigned int size = insn->size;

usr/src/tools/smatch/src/simplify.c

518

long long left = insn->src1->value;

usr/src/tools/smatch/src/simplify.c

519

long long right = insn->src2->value;

usr/src/tools/smatch/src/simplify.c

533

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

646

static int simplify_mask_or_and(struct instruction *insn, unsigned long long mask,

usr/src/tools/smatch/src/simplify.c

661

return replace_pseudo(insn, &insn->src1, orb);

usr/src/tools/smatch/src/simplify.c

663

if (multi_users(insn->src1))

usr/src/tools/smatch/src/simplify.c

666

struct instruction *or = insn->src1->def;

usr/src/tools/smatch/src/simplify.c

685

static int simplify_mask_or(struct instruction *insn, unsigned long long mask, struct instruction *or)

usr/src/tools/smatch/src/simplify.c

692

if ((rc = simplify_mask_or_and(insn, mask, src1, src2)))

usr/src/tools/smatch/src/simplify.c

696

if ((rc = simplify_mask_or_and(insn, mask, src2, src1)))

usr/src/tools/smatch/src/simplify.c

705

return replace_pseudo(insn, &insn->src1, src1);

usr/src/tools/smatch/src/simplify.c

709

return replace_pseudo(insn, &insn->src1, value_pseudo(mask));

usr/src/tools/smatch/src/simplify.c

752

static long long check_shift_count(struct instruction *insn, unsigned long long uval)

usr/src/tools/smatch/src/simplify.c

754

unsigned int size = insn->size;

usr/src/tools/smatch/src/simplify.c

763

insn->src2 = value_pseudo(sval);

usr/src/tools/smatch/src/simplify.c

764

if (insn->tainted)

usr/src/tools/smatch/src/simplify.c

768

warning(insn->pos, "shift count is negative (%lld)", sval);

usr/src/tools/smatch/src/simplify.c

770

struct symbol *ctype = insn->type;

usr/src/tools/smatch/src/simplify.c

775

warning(insn->pos, "shift too big (%llu) for type %s", sval, tname);

usr/src/tools/smatch/src/simplify.c

777

insn->tainted = 1;

usr/src/tools/smatch/src/simplify.c

78

static int get_phisources(struct instruction *sources[], int nbr, struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

781

static int simplify_shift(struct instruction *insn, pseudo_t pseudo, long long value)

usr/src/tools/smatch/src/simplify.c

790

return replace_with_pseudo(insn, pseudo);

usr/src/tools/smatch/src/simplify.c

791

value = check_shift_count(insn, value);

usr/src/tools/smatch/src/simplify.c

795

size = insn->size;

usr/src/tools/smatch/src/simplify.c

796

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

806

if (def == insn) // cyclic DAG!

usr/src/tools/smatch/src/simplify.c

812

if (nval > insn->size || nval == 0)

usr/src/tools/smatch/src/simplify.c

816

insn->opcode = OP_LSR;

usr/src/tools/smatch/src/simplify.c

828

insn->opcode = OP_LSR;

usr/src/tools/smatch/src/simplify.c

83

assert(insn->opcode == OP_PHI);

usr/src/tools/smatch/src/simplify.c

833

size = operand_size(insn, pseudo);

usr/src/tools/smatch/src/simplify.c

84

FOR_EACH_PTR(insn->phi_list, phi) {

usr/src/tools/smatch/src/simplify.c

842

mask = bits_mask(insn->size - value) << value;

usr/src/tools/smatch/src/simplify.c

846

return replace_with_pseudo(insn, value_pseudo(0));

usr/src/tools/smatch/src/simplify.c

848

return replace_pseudo(insn, &insn->src1, def->src1);

usr/src/tools/smatch/src/simplify.c

852

def->src2 = insn->src2;

usr/src/tools/smatch/src/simplify.c

853

insn->opcode = OP_AND;

usr/src/tools/smatch/src/simplify.c

854

insn->src2 = value_pseudo(omask >> value);

usr/src/tools/smatch/src/simplify.c

860

return simplify_mask_shift_or(insn, def, mask);

usr/src/tools/smatch/src/simplify.c

864

if (def->src2 != insn->src2)

usr/src/tools/smatch/src/simplify.c

866

mask = bits_mask(insn->size - value);

usr/src/tools/smatch/src/simplify.c

878

mask = bits_mask(insn->size) >> value;

usr/src/tools/smatch/src/simplify.c

882

return replace_with_pseudo(insn, value_pseudo(0));

usr/src/tools/smatch/src/simplify.c

884

return replace_pseudo(insn, &insn->src1, def->src1);

usr/src/tools/smatch/src/simplify.c

890

if (def->src2 != insn->src2)

usr/src/tools/smatch/src/simplify.c

892

mask = bits_mask(insn->size - value) << value;

usr/src/tools/smatch/src/simplify.c

896

return simplify_mask_shift_or(insn, def, mask);

usr/src/tools/smatch/src/simplify.c

899

if (def == insn) // cyclic DAG!

usr/src/tools/smatch/src/simplify.c

905

if (nval > insn->size)

usr/src/tools/smatch/src/simplify.c

916

insn->src2 = value_pseudo(value);

usr/src/tools/smatch/src/simplify.c

917

return replace_pseudo(insn, &insn->src1, pseudo->def->src1);

usr/src/tools/smatch/src/simplify.c

920

return replace_with_pseudo(insn, value_pseudo(0));

usr/src/tools/smatch/src/simplify.c

922

insn->opcode = OP_AND;

usr/src/tools/smatch/src/simplify.c

923

insn->src2 = value_pseudo(mask);

usr/src/tools/smatch/src/simplify.c

924

return replace_pseudo(insn, &insn->src1, def->src1);

usr/src/tools/smatch/src/simplify.c

927

static int simplify_mul_div(struct instruction *insn, long long value)

usr/src/tools/smatch/src/simplify.c

929

unsigned long long sbit = 1ULL << (insn->size - 1);

usr/src/tools/smatch/src/simplify.c

933

return replace_with_pseudo(insn, insn->src1);

usr/src/tools/smatch/src/simplify.c

935

switch (insn->opcode) {

usr/src/tools/smatch/src/simplify.c

938

return replace_with_pseudo(insn, insn->src2);

usr/src/tools/smatch/src/simplify.c

946

insn->opcode = OP_NEG;

usr/src/tools/smatch/src/simplify.c

954

static int simplify_seteq_setne(struct instruction *insn, long long value)

usr/src/tools/smatch/src/simplify.c

956

pseudo_t old = insn->src1;

usr/src/tools/smatch/src/simplify.c

97

static int if_convert_phi(struct instruction *insn)

usr/src/tools/smatch/src/simplify.c

971

inverse = (insn->opcode == OP_SET_NE) == value;

usr/src/tools/smatch/src/simplify.c

972

if (!inverse && def->size == 1 && insn->size == 1) {

usr/src/tools/smatch/src/simplify.c

978

return replace_with_pseudo(insn, old);

usr/src/tools/smatch/src/simplify.c

985

if (def->size != insn->size)

usr/src/tools/smatch/src/simplify.c

991

return replace_with_pseudo(insn, old);

usr/src/tools/smatch/src/sparse-llvm.c

1002

output_op_setval(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1005

output_op_setfval(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1008

output_op_switch(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1014

output_op_phisrc(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1017

output_op_phi(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1020

output_op_load(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1023

output_op_store(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1028

output_op_call(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1031

output_op_cast(fn, insn, LLVMZExt);

usr/src/tools/smatch/src/sparse-llvm.c

1034

output_op_cast(fn, insn, LLVMSExt);

usr/src/tools/smatch/src/sparse-llvm.c

1037

output_op_cast(fn, insn, LLVMTrunc);

usr/src/tools/smatch/src/sparse-llvm.c

1040

output_op_cast(fn, insn, LLVMFPToUI);

usr/src/tools/smatch/src/sparse-llvm.c

1043

output_op_cast(fn, insn, LLVMFPToSI);

usr/src/tools/smatch/src/sparse-llvm.c

1047

output_op_fpcast(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1052

output_op_ptrcast(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1055

output_op_binary(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1058

output_op_compare(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1061

output_op_sel(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1070

src = pseudo_to_value(fn, insn->type, insn->src);

usr/src/tools/smatch/src/sparse-llvm.c

1072

pseudo_name(insn->target, target_name);

usr/src/tools/smatch/src/sparse-llvm.c

1076

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

1084

src = pseudo_to_value(fn, insn->type, insn->src);

usr/src/tools/smatch/src/sparse-llvm.c

1086

pseudo_name(insn->target, target_name);

usr/src/tools/smatch/src/sparse-llvm.c

1088

if (insn->opcode == OP_FNEG)

usr/src/tools/smatch/src/sparse-llvm.c

1093

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

1120

struct instruction *insn;

usr/src/tools/smatch/src/sparse-llvm.c

1122

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/sparse-llvm.c

1123

if (!insn->bb)

usr/src/tools/smatch/src/sparse-llvm.c

1126

output_insn(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

1128

END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/sparse-llvm.c

1164

struct instruction *insn;

usr/src/tools/smatch/src/sparse-llvm.c

1172

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/sparse-llvm.c

1177

if (!insn->bb || insn->opcode != OP_PHI)

usr/src/tools/smatch/src/sparse-llvm.c

1182

phi_type = insn_symbol_type(insn);

usr/src/tools/smatch/src/sparse-llvm.c

1186

insn->target->priv = LLVMBuildLoad(function.builder, ptr, "phi");

usr/src/tools/smatch/src/sparse-llvm.c

1187

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/sparse-llvm.c

221

static LLVMTypeRef insn_symbol_type(struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

223

if (insn->type)

usr/src/tools/smatch/src/sparse-llvm.c

224

return symbol_type(insn->type);

usr/src/tools/smatch/src/sparse-llvm.c

226

switch (insn->size) {

usr/src/tools/smatch/src/sparse-llvm.c

233

die("invalid bit size %d", insn->size);

usr/src/tools/smatch/src/sparse-llvm.c

534

static void output_op_binary(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

539

lhs = get_ioperand(fn, insn->type, insn->src1);

usr/src/tools/smatch/src/sparse-llvm.c

540

rhs = get_ioperand(fn, insn->type, insn->src2);

usr/src/tools/smatch/src/sparse-llvm.c

542

pseudo_name(insn->target, target_name);

usr/src/tools/smatch/src/sparse-llvm.c

544

switch (insn->opcode) {

usr/src/tools/smatch/src/sparse-llvm.c

559

assert(!is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

563

assert(!is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

567

assert(!is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

571

assert(!is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

575

assert(!is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

579

assert(!is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

599

assert(!is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

603

assert(!is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

607

assert(!is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

615

target = adjust_type(fn, insn->type, target);

usr/src/tools/smatch/src/sparse-llvm.c

616

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

619

static void output_op_compare(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

624

lhs = pseudo_to_value(fn, NULL, insn->src1);

usr/src/tools/smatch/src/sparse-llvm.c

625

if (insn->src2->type == PSEUDO_VAL)

usr/src/tools/smatch/src/sparse-llvm.c

626

rhs = constant_value(insn->src2->value, LLVMTypeOf(lhs));

usr/src/tools/smatch/src/sparse-llvm.c

628

rhs = pseudo_to_value(fn, NULL, insn->src2);

usr/src/tools/smatch/src/sparse-llvm.c

630

rhs = LLVMGetUndef(symbol_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

632

pseudo_name(insn->target, target_name);

usr/src/tools/smatch/src/sparse-llvm.c

634

LLVMTypeRef dst_type = insn_symbol_type(insn);

usr/src/tools/smatch/src/sparse-llvm.c

643

LLVMIntPredicate op = translate_op(insn->opcode);

usr/src/tools/smatch/src/sparse-llvm.c

658

LLVMRealPredicate op = translate_fop(insn->opcode);

usr/src/tools/smatch/src/sparse-llvm.c

669

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

672

static void output_op_ret(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

674

pseudo_t pseudo = insn->src;

usr/src/tools/smatch/src/sparse-llvm.c

677

LLVMValueRef result = get_operand(fn, insn->type, pseudo);

usr/src/tools/smatch/src/sparse-llvm.c

683

static LLVMValueRef calc_memop_addr(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

691

off = LLVMConstInt(int_type, insn->offset, 0);

usr/src/tools/smatch/src/sparse-llvm.c

694

src = pseudo_to_value(fn, insn->type, insn->src);

usr/src/tools/smatch/src/sparse-llvm.c

696

addr_type = LLVMPointerType(insn_symbol_type(insn), as);

usr/src/tools/smatch/src/sparse-llvm.c

705

static void output_op_load(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

710

addr = calc_memop_addr(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

713

pseudo_name(insn->target, name);

usr/src/tools/smatch/src/sparse-llvm.c

716

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

719

static void output_op_store(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

723

addr = calc_memop_addr(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

725

target_in = pseudo_to_rvalue(fn, insn->type, insn->target);

usr/src/tools/smatch/src/sparse-llvm.c

754

static void output_op_sel(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

759

src1 = bool_value(fn, pseudo_to_value(fn, NULL, insn->src1));

usr/src/tools/smatch/src/sparse-llvm.c

760

src2 = get_operand(fn, insn->type, insn->src2);

usr/src/tools/smatch/src/sparse-llvm.c

761

src3 = get_operand(fn, insn->type, insn->src3);

usr/src/tools/smatch/src/sparse-llvm.c

763

pseudo_name(insn->target, name);

usr/src/tools/smatch/src/sparse-llvm.c

766

insn->target->priv = adjust_type(fn, insn->type, target);

usr/src/tools/smatch/src/sparse-llvm.c

769

static void output_op_switch(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

776

FOR_EACH_PTR(insn->multijmp_list, jmp) {

usr/src/tools/smatch/src/sparse-llvm.c

783

sw_val = get_ioperand(fn, insn->type, insn->cond);

usr/src/tools/smatch/src/sparse-llvm.c

787

FOR_EACH_PTR(insn->multijmp_list, jmp) {

usr/src/tools/smatch/src/sparse-llvm.c

791

LLVMValueRef Val = val_to_value(val, insn->type);

usr/src/tools/smatch/src/sparse-llvm.c

797

static void output_op_call(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

806

n_arg = pseudo_list_size(insn->arguments);

usr/src/tools/smatch/src/sparse-llvm.c

809

PREPARE_PTR_LIST(insn->fntypes, ctype);

usr/src/tools/smatch/src/sparse-llvm.c

810

if (insn->func->type == PSEUDO_REG || insn->func->type == PSEUDO_PHI)

usr/src/tools/smatch/src/sparse-llvm.c

811

func = get_operand(fn, ctype, insn->func);

usr/src/tools/smatch/src/sparse-llvm.c

813

func = pseudo_to_value(fn, ctype, insn->func);

usr/src/tools/smatch/src/sparse-llvm.c

815

FOR_EACH_PTR(insn->arguments, arg) {

usr/src/tools/smatch/src/sparse-llvm.c

821

pseudo_name(insn->target, name);

usr/src/tools/smatch/src/sparse-llvm.c

824

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

827

static void output_op_phisrc(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

832

assert(insn->target->priv == NULL);

usr/src/tools/smatch/src/sparse-llvm.c

835

v = get_operand(fn, insn->type, insn->phi_src);

usr/src/tools/smatch/src/sparse-llvm.c

837

FOR_EACH_PTR(insn->phi_users, phi) {

usr/src/tools/smatch/src/sparse-llvm.c

850

static void output_op_phi(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

852

LLVMValueRef load = insn->target->priv;

usr/src/tools/smatch/src/sparse-llvm.c

862

static void output_op_ptrcast(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

866

struct symbol *otype = insn->orig_type;

usr/src/tools/smatch/src/sparse-llvm.c

870

src = get_operand(fn, otype, insn->src);

usr/src/tools/smatch/src/sparse-llvm.c

871

pseudo_name(insn->target, target_name);

usr/src/tools/smatch/src/sparse-llvm.c

873

dtype = symbol_type(insn->type);

usr/src/tools/smatch/src/sparse-llvm.c

874

switch (insn->opcode) {

usr/src/tools/smatch/src/sparse-llvm.c

878

assert(is_ptr_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

883

assert(is_int_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

889

assert(is_ptr_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

897

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

900

static void output_op_cast(struct function *fn, struct instruction *insn, LLVMOpcode op)

usr/src/tools/smatch/src/sparse-llvm.c

904

struct symbol *otype = insn->orig_type;

usr/src/tools/smatch/src/sparse-llvm.c

907

if (is_ptr_type(insn->type)) // cast to void* is OP_CAST ...

usr/src/tools/smatch/src/sparse-llvm.c

908

return output_op_ptrcast(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

910

assert(is_int_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

912

src = get_operand(fn, otype, insn->src);

usr/src/tools/smatch/src/sparse-llvm.c

913

pseudo_name(insn->target, target_name);

usr/src/tools/smatch/src/sparse-llvm.c

915

dtype = symbol_type(insn->type);

usr/src/tools/smatch/src/sparse-llvm.c

922

if (insn->size < width)

usr/src/tools/smatch/src/sparse-llvm.c

924

else if (insn->size == width)

usr/src/tools/smatch/src/sparse-llvm.c

931

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

934

static void output_op_fpcast(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

936

LLVMTypeRef dtype = symbol_type(insn->type);

usr/src/tools/smatch/src/sparse-llvm.c

938

struct symbol *otype = insn->orig_type;

usr/src/tools/smatch/src/sparse-llvm.c

941

assert(is_float_type(insn->type));

usr/src/tools/smatch/src/sparse-llvm.c

943

pseudo_name(insn->target, name);

usr/src/tools/smatch/src/sparse-llvm.c

944

src = get_operand(fn, otype, insn->src);

usr/src/tools/smatch/src/sparse-llvm.c

945

switch (insn->opcode) {

usr/src/tools/smatch/src/sparse-llvm.c

958

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

961

static void output_op_setval(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

963

struct expression *val = insn->val;

usr/src/tools/smatch/src/sparse-llvm.c

974

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

977

static void output_op_setfval(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

979

LLVMTypeRef dtype = symbol_type(insn->type);

usr/src/tools/smatch/src/sparse-llvm.c

982

target = LLVMConstReal(dtype, insn->fvalue);

usr/src/tools/smatch/src/sparse-llvm.c

983

insn->target->priv = target;

usr/src/tools/smatch/src/sparse-llvm.c

986

static void output_insn(struct function *fn, struct instruction *insn)

usr/src/tools/smatch/src/sparse-llvm.c

988

switch (insn->opcode) {

usr/src/tools/smatch/src/sparse-llvm.c

990

output_op_ret(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

993

output_op_br(fn, insn);

usr/src/tools/smatch/src/sparse-llvm.c

996

output_op_cbr(fn, insn);

usr/src/tools/smatch/src/sparse.c

118

static void check_cast_instruction(struct instruction *insn)

usr/src/tools/smatch/src/sparse.c

120

struct symbol *orig_type = insn->orig_type;

usr/src/tools/smatch/src/sparse.c

123

int new = insn->size;

usr/src/tools/smatch/src/sparse.c

125

int newsigned = insn->opcode == OP_SEXT;

usr/src/tools/smatch/src/sparse.c

132

warning(insn->pos, "cast loses sign");

usr/src/tools/smatch/src/sparse.c

136

warning(insn->pos, "cast drops bits");

usr/src/tools/smatch/src/sparse.c

140

warning(insn->pos, "cast wasn't removed");

usr/src/tools/smatch/src/sparse.c

143

warning(insn->pos, "cast changes sign");

usr/src/tools/smatch/src/sparse.c

147

static void check_range_instruction(struct instruction *insn)

usr/src/tools/smatch/src/sparse.c

149

warning(insn->pos, "value out of range");

usr/src/tools/smatch/src/sparse.c

152

static void check_byte_count(struct instruction *insn, pseudo_t count)

usr/src/tools/smatch/src/sparse.c

159

warning(insn->pos, "%s with byte count of %llu",

usr/src/tools/smatch/src/sparse.c

160

show_ident(insn->func->sym->ident), val);

usr/src/tools/smatch/src/sparse.c

177

static void check_memset(struct instruction *insn)

usr/src/tools/smatch/src/sparse.c

179

check_byte_count(insn, argument(insn, 3));

usr/src/tools/smatch/src/sparse.c

188

void (*check)(struct instruction *insn);

usr/src/tools/smatch/src/sparse.c

191

static void check_call_instruction(struct instruction *insn)

usr/src/tools/smatch/src/sparse.c

193

pseudo_t fn = insn->func;

usr/src/tools/smatch/src/sparse.c

211

check_fn[i].check(insn);

usr/src/tools/smatch/src/sparse.c

216

static void check_one_instruction(struct instruction *insn)

usr/src/tools/smatch/src/sparse.c

218

switch (insn->opcode) {

usr/src/tools/smatch/src/sparse.c

222

check_cast_instruction(insn);

usr/src/tools/smatch/src/sparse.c

225

check_range_instruction(insn);

usr/src/tools/smatch/src/sparse.c

228

check_call_instruction(insn);

usr/src/tools/smatch/src/sparse.c

237

struct instruction *insn;

usr/src/tools/smatch/src/sparse.c

238

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/sparse.c

239

if (!insn->bb)

usr/src/tools/smatch/src/sparse.c

241

check_one_instruction(insn);

usr/src/tools/smatch/src/sparse.c

242

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/sparse.c

46

struct instruction *insn;

usr/src/tools/smatch/src/sparse.c

48

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/sparse.c

50

if (!insn->bb)

usr/src/tools/smatch/src/sparse.c

52

if (insn->opcode != OP_CONTEXT)

usr/src/tools/smatch/src/sparse.c

54

val = insn->increment;

usr/src/tools/smatch/src/sparse.c

55

if (insn->check) {

usr/src/tools/smatch/src/sparse.c

62

warning(insn->pos, "context check failure");

usr/src/tools/smatch/src/sparse.c

66

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/sparse.c

83

struct instruction *insn;

usr/src/tools/smatch/src/sparse.c

86

insn = last_instruction(bb->insns);

usr/src/tools/smatch/src/sparse.c

87

if (!insn)

usr/src/tools/smatch/src/sparse.c

89

if (insn->opcode == OP_RET)

usr/src/tools/smatch/src/ssa.c

104

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/ssa.c

106

if (!insn->bb || insn->src != addr)

usr/src/tools/smatch/src/ssa.c

108

switch (insn->opcode) {

usr/src/tools/smatch/src/ssa.c

112

convert_load_instruction(insn, val);

usr/src/tools/smatch/src/ssa.c

115

val = insn->target;

usr/src/tools/smatch/src/ssa.c

118

kill_store(insn);

usr/src/tools/smatch/src/ssa.c

121

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/ssa.c

130

struct instruction *insn = pu->insn;

usr/src/tools/smatch/src/ssa.c

132

if (insn->opcode != OP_LOAD)

usr/src/tools/smatch/src/ssa.c

139

if (insn->bb == store->bb) {

usr/src/tools/smatch/src/ssa.c

142

if (!insn_before(store, insn))

usr/src/tools/smatch/src/ssa.c

144

} else if (!domtree_dominates(store->bb, insn->bb)) {

usr/src/tools/smatch/src/ssa.c

153

convert_load_instruction(insn, store->target);

usr/src/tools/smatch/src/ssa.c

203

struct instruction *insn = pu->insn;

usr/src/tools/smatch/src/ssa.c

204

struct basic_block *bb = insn->bb;

usr/src/tools/smatch/src/ssa.c

206

switch (insn->opcode) {

usr/src/tools/smatch/src/ssa.c

209

store = insn;

usr/src/tools/smatch/src/ssa.c

270

static void ssa_rename_insn(struct basic_block *bb, struct instruction *insn)

usr/src/tools/smatch/src/ssa.c

276

switch (insn->opcode) {

usr/src/tools/smatch/src/ssa.c

278

addr = insn->src;

usr/src/tools/smatch/src/ssa.c

284

phi_map_update(&bb->phi_map, var, insn->target);

usr/src/tools/smatch/src/ssa.c

285

kill_store(insn);

usr/src/tools/smatch/src/ssa.c

288

addr = insn->src;

usr/src/tools/smatch/src/ssa.c

295

convert_load_instruction(insn, val);

usr/src/tools/smatch/src/ssa.c

298

var = insn->type;

usr/src/tools/smatch/src/ssa.c

301

phi_map_update(&bb->phi_map, var, insn->target);

usr/src/tools/smatch/src/ssa.c

302

add_instruction(&phis_all, insn);

usr/src/tools/smatch/src/ssa.c

312

struct instruction *insn;

usr/src/tools/smatch/src/ssa.c

313

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/ssa.c

314

if (!insn->bb)

usr/src/tools/smatch/src/ssa.c

316

ssa_rename_insn(bb, insn);

usr/src/tools/smatch/src/ssa.c

317

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/ssa.c

336

static void ssa_rename_phi(struct instruction *insn)

usr/src/tools/smatch/src/ssa.c

341

if (!insn->phi_var)

usr/src/tools/smatch/src/ssa.c

343

var = insn->phi_var->sym;

usr/src/tools/smatch/src/ssa.c

346

FOR_EACH_PTR(insn->bb->parents, par) {

usr/src/tools/smatch/src/ssa.c

352

use_pseudo(insn, phi, add_pseudo(&insn->phi_list, phi));

usr/src/tools/smatch/src/ssa.c

77

struct instruction *insn;

usr/src/tools/smatch/src/ssa.c

80

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/ssa.c

81

if (insn == a)

usr/src/tools/smatch/src/ssa.c

83

if (insn == b)

usr/src/tools/smatch/src/ssa.c

85

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/ssa.c

89

static void kill_store(struct instruction *insn)

usr/src/tools/smatch/src/ssa.c

91

remove_use(&insn->src);

usr/src/tools/smatch/src/ssa.c

92

remove_use(&insn->target);

usr/src/tools/smatch/src/ssa.c

93

insn->bb = NULL;

usr/src/tools/smatch/src/ssa.c

98

struct instruction *insn;

usr/src/tools/smatch/src/storage.c

271

struct instruction *insn;

usr/src/tools/smatch/src/storage.c

272

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/storage.c

276

if (!insn->bb || insn->opcode != OP_PHISOURCE)

usr/src/tools/smatch/src/storage.c

279

FOR_EACH_PTR(insn->phi_users, phi) {

usr/src/tools/smatch/src/storage.c

289

PACK_PTR_LIST(&insn->phi_users);

usr/src/tools/smatch/src/storage.c

290

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/test-unssa.c

12

struct instruction *insn;

usr/src/tools/smatch/src/test-unssa.c

17

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/test-unssa.c

18

if (!insn->bb)

usr/src/tools/smatch/src/test-unssa.c

20

printf("\t%s\n", show_instruction(insn));

usr/src/tools/smatch/src/test-unssa.c

22

END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/unssa.c

119

struct instruction *insn;

usr/src/tools/smatch/src/unssa.c

124

FOR_EACH_PTR(bb->insns, insn) {

usr/src/tools/smatch/src/unssa.c

125

if (!insn->bb)

usr/src/tools/smatch/src/unssa.c

127

if (insn->opcode != OP_PHI)

usr/src/tools/smatch/src/unssa.c

129

replace_phi_node(insn);

usr/src/tools/smatch/src/unssa.c

130

} END_FOR_EACH_PTR(insn);

usr/src/tools/smatch/src/unssa.c

56

use_pseudo(pu->insn, tmp, pu->userp);

usr/src/tools/smatch/src/unssa.c

94

struct instruction *insn;

usr/src/tools/smatch/src/unssa.c

96

insn = src->def;

usr/src/tools/smatch/src/unssa.c

97

if (!insn)

usr/src/tools/smatch/src/unssa.c

99

insn->target = tmp;

usr/src/uts/intel/os/archdep.c

435

uint32_t insn;

usr/src/uts/intel/os/archdep.c

446

if (fuword32((void *)(upc - 2), &insn) != -1 &&

usr/src/uts/intel/os/archdep.c

447

(insn & 0xffff) == 0x340f || (insn & 0xffff) == 0x050f)