Struct CallOp

pub struct CallOp { /* private fields */ }

llvm.call

`llvm.call` $callee `(` $operands `)` attr-dict `:` `(` type($operands) `)` -> type($results)

Implementations

impl CallOp

pub fn identifier(&self) -> Option<String>

Trait Implementations

impl Call for CallOp

fn identifier(&self) -> Option<String>

fn set_identifier(&mut self, identifier: String)

fn varargs(&self) -> Option<Shared<dyn Type>>

fn set_varargs(&mut self, varargs: Option<Shared<dyn Type>>)

fn display_call_op(&self, f: &mut Formatter<'_>) -> Result

fn parse_call_op<T: ParserDispatch, O: Call + 'static>( parser: &mut Parser<T>, parent: Option<Shared<Block>>, allow_varargs: bool, ) -> Result<Shared<O>>

Parse a call op such as llvm.call.

impl Op for CallOp

fn operation_name() -> OperationName

fn new(operation: Shared<Operation>) -> Self

Create an new Op from an Operation.

fn as_any(&self) -> &dyn Any

fn operation(&self) -> &Shared<Operation>

fn display(&self, f: &mut Formatter<'_>, _indent: i32) -> Result

Display the operation with the given indentation.

fn from_operation_arc(operation: Shared<Operation>) -> Self

where Self: Sized,

Create an Op from an Operation wrapped in an Arc.

fn from_operation(operation: Operation) -> Self

where Self: Sized,

Create an Op from an Operation.

fn name(&self) -> OperationName

fn region(&self) -> Option<Shared<Region>>

fn assignments(&self) -> Result<Values>

Returns the values which this Op assigns to. For most ops, this is the results field of type OpResult. But for some other ops like FuncOp, this can be different.

fn canonicalize(&self) -> RewriteResult

fn is_terminator(&self) -> bool

fn is_func(&self) -> bool

fn is_const(&self) -> bool

fn is_pure(&self) -> bool

fn attribute(&self, key: &str) -> Option<Arc<dyn Attribute>>

fn insert_before(&self, earlier: Shared<dyn Op>)

Insert earlier before self inside self’s parent block.

fn insert_after(&self, later: Shared<dyn Op>)

Insert later after self inside self’s parent block.

fn remove(&self)

Remove the operation from its parent block.

fn replace(&self, new: Shared<dyn Op>)

Replace self with new by moving the results of the old operation to the results of the specified new op, and pointing the result.defining_op to the new op. In effect, this makes all the uses of the old op refer to the new op instead.

fn ops(&self) -> Vec<Shared<dyn Op>>

Return ops that are children of this op (inside blocks that are inside the region).

fn parent_op(&self) -> Option<Shared<dyn Op>>

fn set_parent(&self, parent: Shared<Block>)

fn result(&self, index: usize) -> Shared<Value>

Return the result at the given index.

impl Parse for CallOp

fn op<T: ParserDispatch>( parser: &mut Parser<T>, parent: Option<Shared<Block>>, ) -> Result<Shared<dyn Op>>