}
  }
  return success();
}

LogicalResult CopyNonSymbolRefAttrs(CallOp src, Operation* dst) {
  NamedAttrList attrs;
  CollectAllowedAttrs(src, &attrs);

  for (auto& attr : attrs) {
    dst->setAttr(attr.getName(), attr.getValue());
  }

  return success();
}

void PropagateAttrsToOperations(CallOp src, Block::iterator begin,
                                Block::iterator end) {

    auto entry_func_op = dyn_cast_or_null<func::FuncOp>(
        symbol_table.lookup(GetEntryFunctionName(op)));
    if (!entry_func_op) return failure();

    // Replace the XlaCallModuleOp with a new CallOp.
    rewriter.replaceOpWithNewOp<func::CallOp>(op, entry_func_op, op.getArgs());
    return success();
  }
};

void XlaCallModuleToCallPass::runOnOperation() {
  ModuleOp module_op = getOperation();

static void clobber_stack() {
	volatile char a[1024];
	int i;
	for(i = 0; i < sizeof a; i++)
		a[i] = 0xff;
}

static int call_go() {
	GoString s;
	s.p = "test";
	s.n = 4;
	return issue5548FromC(s, 42);
}

int issue5548_in_c() {
	clobber_stack();
	return call_go();

            <caret_context>val x = 0
        }
    }
}

fun callFoo(foo: Foo): Int {
    return 0
}

fun callString(string: String): Int {
    return 1
}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION

TEXT ·And32(SB), NOSPLIT, $0-12
	MOVL	ptr+0(FP), BX
	MOVL	val+4(FP), CX
casloop:
	MOVL 	CX, DX
	MOVL	(BX), AX
	ANDL	AX, DX
	LOCK
	CMPXCHGL	DX, (BX)
	JNZ casloop
	MOVL 	AX, ret+8(FP)
	RET

// func Or32(addr *uint32, v uint32) old uint32
TEXT ·Or32(SB), NOSPLIT, $0-12
	MOVL	ptr+0(FP), BX
	MOVL	val+4(FP), CX
casloop:
	MOVL 	CX, DX
	MOVL	(BX), AX
	ORL	AX, DX
	LOCK
	CMPXCHGL	DX, (BX)

import jcifs.smb1.dcerpc.ndr.*;

public abstract class DcerpcMessage extends NdrObject implements DcerpcConstants {

    protected int ptype = -1;
    protected int flags = 0;
    protected int length = 0;
    protected int call_id = 0;
    protected int alloc_hint = 0;
    protected int result = 0;

    public boolean isFlagSet(int flag) {
        return (flags & flag) == flag;
    }
    public void unsetFlag(int flag) {

  // only executes ops with no side effects.
  mutable llvm::SmallDenseMap<Operation*, bool> is_pure_function_;
};

bool OpSideEffectCollector::IsCallToPureFunction(Operation* callOp) const {
  auto call = llvm::dyn_cast<CallOpInterface>(callOp);
  if (!call)
    return false;  // not a call
  func::FuncOp func_op = dyn_cast<func::FuncOp>(call.resolveCallable(
      &symbol_table_collection_));
  return IsPureFunction(func_op);

    rewriter.replaceOpWithNewOp<TFR::ConstOp>(bl_op, array_attr);
    return success();
  }
};

quant::QuantizedType getQuantizedElementType(CastOp cast_op) {
  if (!cast_op || !cast_op.getInputElementType()) {
    return {};
  }
  return cast_op.getInputElementType()
      .cast<TypeAttr>()
      .getValue()
      .dyn_cast<quant::QuantizedType>();
}

/**
 * 
 */
public abstract class DcerpcMessage extends NdrObject implements DcerpcConstants {

    protected int ptype = -1;
    protected int flags = 0;
    protected int length = 0;
    protected int call_id = 0;
    protected int alloc_hint = 0;
    protected int result = 0;


    /**
     * 
     * @param flag
     * @return whether flag is set
     */
    public boolean isFlagSet ( int flag ) {

    }
    if_op.getResult(i).replaceAllUsesWith(
        if_op.getOperand(then_forward_input + 1));
  }
  if_op.erase();
  return success();
}

template <typename CallOp>
LogicalResult HandlePartitionedCallOp(
    CallOp call, func::FuncOp callee, ModuleOp module,
    llvm::SmallDenseMap<Value, TensorArrayStats>* stats,
    llvm::StringMap<PartitionedCallTensorArrayOpsInfo>*