#include "program.h"
#include "stmt.h"
-namespace Fortran::IntermediateRepresentation {
+namespace Fortran::FIR {
BasicBlock::BasicBlock(Region *parentRegion, BasicBlock *insertBefore)
: ChildMixin{parentRegion} {
}
void BasicBlock::addPred(BasicBlock *bb) {
- for (auto *p : predecessors_) {
+ for (auto *p : preds_) {
if (p == bb) return;
}
- predecessors_.push_back(bb);
+ preds_.push_back(bb);
}
const Statement *BasicBlock::getTerminator() const {
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef FORTRAN_INTERMEDIATEREPRESENTATION_BASICBLOCK_H_
-#define FORTRAN_INTERMEDIATEREPRESENTATION_BASICBLOCK_H_
+#ifndef FORTRAN_FIR_BASICBLOCK_H_
+#define FORTRAN_FIR_BASICBLOCK_H_
#include "mixin.h"
#include "region.h"
#include <iostream>
-namespace Fortran::IntermediateRepresentation {
+namespace Fortran::FIR {
class Region;
class Statement;
void SetRegion(Region *region) { parent = region; }
Region *GetRegion() const { return parent; }
void addPred(BasicBlock *bb);
- std::vector<BasicBlock *> &Predecessors() { return predecessors_; }
+ std::vector<BasicBlock *> &preds() { return preds_; }
StatementListType &Statements() { return statementList_; }
BasicBlock *SplitEdge(BasicBlock *toBlock) { return nullptr; }
private:
StatementListType statementList_;
- std::vector<BasicBlock *> predecessors_;
+ std::vector<BasicBlock *> preds_;
explicit BasicBlock(Region *parentRegion, BasicBlock *insertBefore);
};
inline std::list<BasicBlock *> pred_list(BasicBlock &block) {
return std::list<BasicBlock *>{
- block.Predecessors().begin(), block.Predecessors().end()};
+ block.preds().begin(), block.preds().end()};
}
}
#include "procedure.h"
-namespace Fortran::IntermediateRepresentation {
+namespace Fortran::FIR {
Procedure::Procedure(Program *program, FunctionType *ty, LinkageTypes lt,
unsigned addrSpace, const llvm::Twine &n, Procedure *before)
for (auto &block : GetBlocks()) {
auto *region{block.GetRegion()};
if (!region->IsOutermost()) {
- for (auto *successor : succ_list(block)) {
- auto *successorRegion{successor->GetRegion()};
- if (successorRegion != region &&
- DistinctScopes(successorRegion, region)) {
- if (IsAncestor(region, successorRegion)) {
- AddEnterScopes(RegionDepth(region, successorRegion),
- successor->SplitEdge(&block));
- } else if (IsAncestor(successorRegion, region)) {
- AddExitScopes(RegionDepth(successorRegion, region),
- block.SplitEdge(successor));
+ for (auto *succ : succ_list(block)) {
+ auto *succRegion{succ->GetRegion()};
+ if (succRegion != region &&
+ DistinctScopes(succRegion, region)) {
+ if (IsAncestor(region, succRegion)) {
+ AddEnterScopes(RegionDepth(region, succRegion),
+ succ->SplitEdge(&block));
+ } else if (IsAncestor(succRegion, region)) {
+ AddExitScopes(RegionDepth(succRegion, region),
+ block.SplitEdge(succ));
} else {
// TODO: edge to a cousin region
CHECK(false);
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef FORTRAN_INTERMEDIATEREPRESENTATION_PROCEDURE_H_
-#define FORTRAN_INTERMEDIATEREPRESENTATION_PROCEDURE_H_
+#ifndef FORTRAN_FIR_PROCEDURE_H_
+#define FORTRAN_FIR_PROCEDURE_H_
#include "mixin.h"
#include "program.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
-namespace Fortran::IntermediateRepresentation {
+namespace Fortran::FIR {
class Program;
class Region;
#include "program.h"
-namespace Fortran::IntermediateRepresentation {
+namespace Fortran::FIR {
Program::Program(llvm::StringRef id) : name_{id} {}
-Program::~Program() { procedureMap_.clear(); }
void Program::insertBefore(Procedure *subprog, Procedure *before) {
if (before) {
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef FORTRAN_INTERMEDIATEREPRESENTATION_PROGRAM_H_
-#define FORTRAN_INTERMEDIATEREPRESENTATION_PROGRAM_H_
+#ifndef FORTRAN_FIR_PROGRAM_H_
+#define FORTRAN_FIR_PROGRAM_H_
#include "common.h"
#include "procedure.h"
#include "llvm/ADT/Twine.h"
#include <string>
-namespace Fortran::IntermediateRepresentation {
+namespace Fortran::FIR {
class Procedure;
struct GraphWriter;
using ProcedureMapType = llvm::StringMap<Procedure *>;
explicit Program(llvm::StringRef id);
- ~Program();
void insertBefore(Procedure *subprog, Procedure *before = nullptr);
ProcedureListType &getSublist(Procedure *) { return procedureList_; }
bool containsProcedure(llvm::StringRef name) {
#include "program.h"
-namespace Fortran::IntermediateRepresentation {
+namespace Fortran::FIR {
Region::Region(
Procedure *procedure, Scope *scope, Region *inRegion, Region *insertBefore)
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef FORTRAN_INTERMEDIATEREPRESENTATION_REGION_H_
-#define FORTRAN_INTERMEDIATEREPRESENTATION_REGION_H_
+#ifndef FORTRAN_FIR_REGION_H_
+#define FORTRAN_FIR_REGION_H_
#include "procedure.h"
#include "stmt.h"
#include "../semantics/semantics.h"
-namespace Fortran::IntermediateRepresentation {
+namespace Fortran::FIR {
class Procedure;
class BasicBlock;