Lines Matching defs:absent
267 // Optional case (not that optional allocatable/pointer cannot be absent
461 /// absent. This can only be called with numerical or logical scalar \p exv.
462 /// If \p exv is considered absent according to 15.5.2.12 point 1., the returned
486 /// absent. If \p exv is considered absent according to 15.5.2.12 point 1., the
492 // If it is an exv pointer/allocatable, then it cannot be absent
502 /// absent. If \p exv is considered absent according to 15.5.2.12 point 1., the
503 /// returned value is an absent fir.box, otherwise it is a fir.box describing \p
514 // Optional allocatable/pointer -> Cannot be absent, but need to translate
515 // unallocated/diassociated into absent fir.box.
520 // absent. The created fir.box will not be usable, but the SelectOp below
524 auto absent = builder.create<fir::AbsentOp>(loc, boxType);
526 loc, boxType, isPresent, box, absent);
587 /// code may need to unconditionally read a fir.box that can be absent.
734 /// semantics as an absent optional box value. Note: this code should
2406 /// Lower a designator to a variable that may be absent at runtime into an
2413 /// where the actual may be an absent fir.box.
2419 // it is as if the argument was absent. The main care here is to
2422 // therefore the argument would not be considered absent on the
2424 // absent as per 15.5.2.12 point 7. and 8. We rely on this to
2436 // fir.box is absent.
2448 /// Create a temp on the stack for scalar actual arguments that may be absent
2485 /// true. It handles the cases where the actual may be absent, and all of the
2487 /// If the actual argument may be dynamically absent, return an additional
2544 mlir::Value absent =
2546 builder.create<fir::ResultOp>(loc, absent);
2551 // Actual cannot be absent, the actual argument can safely be
2762 auto absent = builder.create<fir::AbsentOp>(loc, argTy);
2765 loc, *isPresentValue, convertedBox, absent));
2775 // absent fir.box must be created instead of a fir.box with a null
2778 // Note that passing an absent allocatable to a non-allocatable
2780 // nothing has to be done to generate an absent argument in this case,
2786 auto absent = builder.create<fir::AbsentOp>(loc, argTy);
2812 loc, isAllocated, convertedBox, absent));
2837 auto absent =
2839 builder.create<fir::ResultOp>(loc, absent);
2874 auto absent =
2877 builder.create<fir::ResultOp>(loc, absent);
3266 /// Can this operand be absent ?
4141 /// Returns the first array operand that may not be absent. If all
4142 /// array operands may be absent, return the first one.
4149 // is allowed to be absent as per 15.5.2.12 point 3. (6). Just pick the
4580 /// a nullptr (because this is an absent optional or unallocated/disassociated
4723 // a potentially absent argument to something else than a value (apart
4793 auto absent = builder.create<fir::AbsentOp>(loc, argTy);
4794 operands.emplace_back([=](IterSpace) { return absent; });
5984 // Generate an array load and access to an array that may be an absent
5999 // Pointer optional arrays cannot be absent. The only kind of entities
6037 /// be dynamically absent (i.e. when it is a POINTER, an ALLOCATABLE or an