Struct ShlOp 

pub struct ShlOp { /* private fields */ }

Equivalent to LLVM’s Shl opcode.

Attributes:

key	value	via Interface
ATTR_KEY_INTEGER_OVERFLOW_FLAGS	IntegerOverflowFlagsAttr	IntBinArithOpWithOverflowFlag

Operands:

operand	description
lhs	Signless integer
rhs	Signless integer

Result(s):

result	description
res	Signless integer

Trait Implementations

impl BinArithOp for ShlOp

fn new(ctx: &mut Context, lhs: Value, rhs: Value) -> Self

where Self: Sized,

Create a new binary arithmetic operation given the operands.

fn lhs(&self, ctx: &Context) -> Value

where Self: Sized,

Get the left-hand side operand of this binary arithmetic Op.

fn rhs(&self, ctx: &Context) -> Value

where Self: Sized,

Get the right-hand side operand of this binary arithmetic Op.

impl Clone for ShlOp

fn clone(&self) -> ShlOp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConstFoldInterface for ShlOp

fn check_fold( &self, ctx: &Context, ops: &[Option<AttrObj>], ) -> Vec<Option<AttrObj>>

Given a slice operand_attrs corresponding to each operand, indicating a known compile time constant value for that operand (if any), returns a vector corresponding to each result, indicating the folded (inferred constant) value, if any.

fn fold_in_place( &self, ctx: &mut Context, ops: &[Option<AttrObj>], rw: &mut dyn Rewriter, ) -> IRStatus

Given a slice operand_attrs corresponding to each operand, indicating a known compile time constant value for that operand (if any), attempts to fold the op in place using the provided rewriter. Assumes that rewriter is positioned just before the op to be folded.

fn fold_with_materialization( &self, ctx: &mut Context, operand_attrs: &[Option<Box<dyn Attribute>>], rewriter: &mut dyn Rewriter, ) -> IRStatus

A helper for implementing fold_in_place by materializing the constants inferred by check_fold.

impl Hash for ShlOp

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntBinArithOpWithOverflowFlag for ShlOp

fn new_with_overflow_flag( ctx: &mut Context, lhs: Value, rhs: Value, flag: IntegerOverflowFlagsAttr, ) -> Self

where Self: Sized,

Create a new integer binary op with overflow flags set.

fn integer_overflow_flag(&self, ctx: &Context) -> IntegerOverflowFlagsAttr

where Self: Sized,

Get the integer overflow flag on this Op.

fn set_integer_overflow_flag( &self, ctx: &Context, flag: IntegerOverflowFlagsAttr, )

where Self: Sized,

Set the integer overflow flag for this Op.

impl NOpdsInterface<2> for ShlOp

fn get_operand_i(&self, ctx: &Context, i: LessThanN<N>) -> Value

Get the i’th operand.

fn operand_type_i(&self, ctx: &Context, i: LessThanN<N>) -> TypeHandle

Get the type of the i’th operand.

impl OneResultInterface for ShlOp

fn get_result(&self, ctx: &Context) -> Value

Get the single result defined by this Op.

fn result_type(&self, ctx: &Context) -> TypeHandle

Get the type of the single result defined by this Op.

impl Op for ShlOp

fn get_operation(&self) -> Ptr<Operation>

Get the underlying IR Operation

fn get_opid(&self) -> OpId

Get this Op’s OpId

fn get_opid_static() -> OpId

Get this Op’s OpId, without self reference.

fn get_concrete_op_info() -> (fn(Ptr<Operation>) -> OpBox, TypeId)

where Self: Sized,

Get details about the concrete Op type.

fn register(ctx: &mut Context)

where Self: Sized + Parsable<Arg = Vec<(Identifier, Location)>, Parsed = OpBox>,

Register Op in Context and add it to its dialect.

fn loc(&self, ctx: &Context) -> Location

Get Op’s location

impl Parsable for ShlOp

type Arg = Vec<(Identifier, Location)>

Type of the argument that must be passed to the parser.

type Parsed = OpBox

The type of the parsed entity.

fn parse<'__pliron_parse>( state_stream: &mut StateStream<'__pliron_parse>, arg: Self::Arg, ) -> ParseResult<'__pliron_parse, Self::Parsed>

Define a parser using existing combinators and call into on [Parser::parse_stream] to get the final ParseResult. Use state_stream.state as necessary.

fn parser<'a>( arg: Self::Arg, ) -> Box<dyn Parser<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, PartialState = (), Output = Self::Parsed> + 'a>

where Self::Parsed: 'a,

Get a parser combinator that can work on StateStream as its input.

impl PartialEq for ShlOp

fn eq(&self, other: &ShlOp) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Printable for ShlOp

fn fmt(&self, ctx: &Context, state: &State, fmt: &mut Formatter<'_>) -> Result

fn disp<'t, 'c>(&'t self, ctx: &'c Context) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and default State.

fn print<'t, 'c>( &'t self, ctx: &'c Context, state: &State, ) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and State.

impl SameOperandsAndResultType for ShlOp

fn common_type(&self, ctx: &Context) -> Option<TypeHandle>

Get the common type of results / operands.

impl SameOperandsType for ShlOp

fn common_operand_type(&self, ctx: &Context) -> Option<TypeHandle>

Get the common type of the operands.

impl SameResultsType for ShlOp

fn common_result_type(&self, ctx: &Context) -> Option<TypeHandle>

Get the common type of the results.

impl SideEffects for ShlOp

fn has_side_effects(&self, _ctx: &Context) -> bool

Returns true if the operation has side effects, and false otherwise.

impl Verify for ShlOp

fn verify(&self, _ctx: &Context) -> Result<()>

impl Copy for ShlOp

impl Eq for ShlOp

impl IntBinArithOp for ShlOp

impl StructuralPartialEq for ShlOp