Lines Matching defs:common

122 // Global variables instantiation (not for alias and common)
622   // Creates zero initializer for globals without initializers, this is a common
627     // Add the common linkage to those to allow some level of support
630     // format, common symbols are assigned a section in shared libraries.
1057 /// This is not to be used for equivalence of common block members (they
1058 /// already have the common block GlobalOp for them, see defineCommonBlock).
1105 /// This is not to be used for equivalence of common block members (they
1106 /// already have the common block GlobalOp for them, see defineCommonBlock).
1214 /// Does any member of the common block has an initializer ?
1226 /// Build a tuple type for a common block based on the common block
1227 /// members and the common block size.
1228 /// This type is only needed to build common block initializers where
1265 /// Common block members may have aliases. They are not in the common block
1267 /// have initializer to generate the common initializer.
1271 getCommonMembersWithInitAliases(const Fortran::semantics::Symbol &common) {
1273       common.get<Fortran::semantics::CommonBlockDetails>();
1276   // The number and size of equivalence and common is expected to be small, so
1278   // common members * common members
1280        common.owner().equivalenceSets())
1288           if (!details->init() || com != &common)
1299 /// Return the fir::GlobalOp that was created of COMMON block \p common.
1306                      const Fortran::semantics::Symbol &common) {
1308   std::string commonName = converter.mangleName(common);
1310   // Common blocks are lowered before any subprograms to deal with common
1313     fir::emitFatalError(converter.genLocation(common.name()),
1318 /// Create the fir::GlobalOp for COMMON block \p common. If \p common has an
1319 /// initial value, it is not created yet. Instead, the common block list
1325                    const Fortran::semantics::Symbol &common,
1328   std::string commonName = converter.mangleName(common);
1333       getCommonMembersWithInitAliases(common);
1334   mlir::Location loc = converter.genLocation(common.name());
1337       common.detailsIf<Fortran::semantics::CommonBlockDetails>();
1338   assert(details && "Expect CommonBlockDetails on the common symbol");
1356   // COMMON block with initializer (note that initialized blank common are
1370 /// \p cmnBlkMems of the common block member symbols that contains symbols with
1420   // Common blocks may depend on another common block address (if they contain
1421   // pointers with initial targets). To cover this case, create all common block
1426   for (const auto &[common, size] : commonBlocks)
1427     if (auto delayedInit = declareCommonBlock(converter, common, size))
1459                               const Fortran::semantics::Symbol &common,
1467   if (Fortran::lower::SymbolBox symBox = symMap.lookupSymbol(common))
1471     fir::GlobalOp global = getCommonBlockGlobal(converter, common);
1475     symMap.addSymbol(common, commonAddr);
1515   // Let the folder deal with the common `ub - <const> + 1` case.
1686   std::optional<Fortran::common::CUDADataAttr> cudaAttr =
1920   std::optional<Fortran::common::CUDADataAttr> cudaAttr =
1923     if (*cudaAttr == Fortran::common::CUDADataAttr::Pinned)
1925     if (*cudaAttr == Fortran::common::CUDADataAttr::Device)
1927     if (*cudaAttr == Fortran::common::CUDADataAttr::Managed)
1929     if (*cudaAttr == Fortran::common::CUDADataAttr::Unified)
2377   if (const Fortran::semantics::Symbol *common =
2379     // Nothing to do, common block are generated before everything. Ensure
2381     getCommonBlockGlobal(converter, *common);
2408   else if (const Fortran::semantics::Symbol *common =
2411     instantiateCommon(converter, *common, var, symMap);
2462     // module or common block variable to satisfy specification expression