diff --git a/flang/include/flang/Optimizer/Transforms/Passes.h b/flang/include/flang/Optimizer/Transforms/Passes.h
--- a/flang/include/flang/Optimizer/Transforms/Passes.h
+++ b/flang/include/flang/Optimizer/Transforms/Passes.h
@@ -9,8 +9,11 @@
 #ifndef FORTRAN_OPTIMIZER_TRANSFORMS_PASSES_H
 #define FORTRAN_OPTIMIZER_TRANSFORMS_PASSES_H
 
+#include "flang/Optimizer/Dialect/FIROps.h"
+
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassRegistry.h"
+
 #include <memory>
 
 namespace mlir {
@@ -27,6 +30,7 @@
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<mlir::Pass> createAbstractResultOnFuncOptPass();
+std::unique_ptr<mlir::Pass> createAbstractResultOnGlobalOptPass();
 std::unique_ptr<mlir::Pass> createAffineDemotionPass();
 std::unique_ptr<mlir::Pass> createArrayValueCopyPass();
 std::unique_ptr<mlir::Pass> createFirToCfgPass();
diff --git a/flang/include/flang/Optimizer/Transforms/Passes.td b/flang/include/flang/Optimizer/Transforms/Passes.td
--- a/flang/include/flang/Optimizer/Transforms/Passes.td
+++ b/flang/include/flang/Optimizer/Transforms/Passes.td
@@ -39,6 +39,10 @@
   let constructor = "::fir::createAbstractResultOnFuncOptPass()";
 }
 
+def AbstractResultOnGlobalOpt : AbstractResultOptBase<"global", "fir::GlobalOp"> {
+  let constructor = "::fir::createAbstractResultOnGlobalOptPass()";
+}
+
 def AffineDialectPromotion : Pass<"promote-to-affine", "::mlir::func::FuncOp"> {
   let summary = "Promotes `fir.{do_loop,if}` to `affine.{for,if}`.";
   let description = [{
diff --git a/flang/include/flang/Tools/CLOptions.inc b/flang/include/flang/Tools/CLOptions.inc
--- a/flang/include/flang/Tools/CLOptions.inc
+++ b/flang/include/flang/Tools/CLOptions.inc
@@ -192,6 +192,8 @@
   fir::addBoxedProcedurePass(pm);
   pm.addNestedPass<mlir::func::FuncOp>(
       fir::createAbstractResultOnFuncOptPass());
+  pm.addNestedPass<fir::GlobalOp>(
+      fir::createAbstractResultOnGlobalOptPass());
   fir::addCodeGenRewritePass(pm);
   fir::addTargetRewritePass(pm);
   fir::addExternalNameConversionPass(pm);
diff --git a/flang/lib/Optimizer/Transforms/AbstractResult.cpp b/flang/lib/Optimizer/Transforms/AbstractResult.cpp
--- a/flang/lib/Optimizer/Transforms/AbstractResult.cpp
+++ b/flang/lib/Optimizer/Transforms/AbstractResult.cpp
@@ -277,9 +277,23 @@
     }
   }
 };
+
+class AbstractResultOnGlobalOpt
+    : public AbstractResultOptTemplate<AbstractResultOnGlobalOpt,
+                                       fir::AbstractResultOnGlobalOptBase> {
+public:
+  void runOnSpecificOperation(fir::GlobalOp, bool, mlir::RewritePatternSet &,
+                              mlir::ConversionTarget &) {
+    // nothing to do
+  }
+};
 } // end anonymous namespace
 } // namespace fir
 
 std::unique_ptr<mlir::Pass> fir::createAbstractResultOnFuncOptPass() {
   return std::make_unique<AbstractResultOnFuncOpt>();
 }
+
+std::unique_ptr<mlir::Pass> fir::createAbstractResultOnGlobalOptPass() {
+  return std::make_unique<AbstractResultOnGlobalOpt>();
+}
diff --git a/flang/lib/Optimizer/Transforms/PassDetail.h b/flang/lib/Optimizer/Transforms/PassDetail.h
--- a/flang/lib/Optimizer/Transforms/PassDetail.h
+++ b/flang/lib/Optimizer/Transforms/PassDetail.h
@@ -9,6 +9,8 @@
 #define FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H
 
 #include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
diff --git a/flang/test/Driver/mlir-pass-pipeline.f90 b/flang/test/Driver/mlir-pass-pipeline.f90
--- a/flang/test/Driver/mlir-pass-pipeline.f90
+++ b/flang/test/Driver/mlir-pass-pipeline.f90
@@ -50,8 +50,11 @@
 ! ALL-NEXT:   (S) 0 num-dce'd - Number of operations DCE'd
 ! ALL-NEXT: BoxedProcedurePass
 
-! ALL-NEXT: 'func.func' Pipeline
-! ALL-NEXT:   AbstractResultOnFuncOpt
+! ALL-NEXT: Pipeline Collection : ['fir.global', 'func.func']
+! ALL-NEXT:   'fir.global' Pipeline
+! ALL-NEXT:    AbstractResultOnGlobalOpt
+! ALL-NEXT:  'func.func' Pipeline
+! ALL-NEXT:    AbstractResultOnFuncOpt
 
 ! ALL-NEXT: CodeGenRewrite
 ! ALL-NEXT:   (S) 0 num-dce'd - Number of operations eliminated
diff --git a/flang/test/Fir/abstract-results.fir b/flang/test/Fir/abstract-results.fir
--- a/flang/test/Fir/abstract-results.fir
+++ b/flang/test/Fir/abstract-results.fir
@@ -3,6 +3,8 @@
 
 // RUN: fir-opt %s --abstract-result-on-func-opt | FileCheck %s --check-prefix=FUNC-REF
 // RUN: fir-opt %s --abstract-result-on-func-opt=abstract-result-as-box | FileCheck %s --check-prefix=FUNC-BOX
+// RUN: fir-opt %s --abstract-result-on-global-opt | FileCheck %s --check-prefix=GLOBAL-REF
+// RUN: fir-opt %s --abstract-result-on-global-opt=abstract-result-as-box | FileCheck %s --check-prefix=GLOBAL-BOX
 
 // ----------------------- Test declaration rewrite ----------------------------
 
@@ -253,3 +255,122 @@
   // FUNC-BOX: fir.call %[[conv]](%[[box]], %c100) : (!fir.box<!fir.array<?xf32>>, index) -> ()
   // FUNC-BOX-NOT: fir.save_result
 }
+
+// ----------------------- Test GlobalOp rewrite ------------------------
+
+// This is needed to separate GlobalOp tests from FuncOp tests for FileCheck
+// FUNC-REF-LABEL: fir.global {{.*}} : {{.*}} {
+// FUNC-BOX-LABEL: fir.global {{.*}} : {{.*}} {
+
+// GLOBAL-REF-LABEL: fir.global @global_call_arrayfunc : i32 {
+// GLOBAL-BOX-LABEL: fir.global @global_call_arrayfunc : i32 {
+fir.global @global_call_arrayfunc : i32 {
+  %c100 = arith.constant 100 : index
+  %buffer = fir.alloca !fir.array<?xf32>, %c100
+  %shape = fir.shape %c100 : (index) -> !fir.shape<1>
+  %res = fir.call @arrayfunc_callee(%c100) : (index) -> !fir.array<?xf32>
+  fir.save_result %res to %buffer(%shape) : !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>>, !fir.shape<1>
+  
+  // GLOBAL-REF: %[[c100:.*]] = arith.constant 100 : index
+  // GLOBAL-REF: %[[buffer:.*]] = fir.alloca !fir.array<?xf32>, %[[c100]]
+  // GLOBAL-REF: fir.call @arrayfunc_callee(%[[buffer]], %[[c100]]) : (!fir.ref<!fir.array<?xf32>>, index) -> ()
+  // GLOBAL-REF-NOT: fir.save_result
+
+  // GLOBAL-BOX: %[[c100:.*]] = arith.constant 100 : index
+  // GLOBAL-BOX: %[[buffer:.*]] = fir.alloca !fir.array<?xf32>, %[[c100]]
+  // GLOBAL-BOX: %[[shape:.*]] = fir.shape %[[c100]] : (index) -> !fir.shape<1>
+  // GLOBAL-BOX: %[[box:.*]] = fir.embox %[[buffer]](%[[shape]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
+  // GLOBAL-BOX: fir.call @arrayfunc_callee(%[[box]], %[[c100]]) : (!fir.box<!fir.array<?xf32>>, index) -> ()
+  // GLOBAL-BOX-NOT: fir.save_result
+
+  %c42 = arith.constant 42 : i32
+  fir.has_value %c42 : i32
+}
+
+// GLOBAL-REF-LABEL: fir.global @global_call_derivedfunc : i32 {
+// GLOBAL-BOX-LABEL: fir.global @global_call_derivedfunc : i32 {
+fir.global @global_call_derivedfunc : i32 {
+  %buffer = fir.alloca !fir.type<t{x:f32}>
+  %cst = arith.constant 4.200000e+01 : f32
+  %res = fir.call @derivedfunc_callee(%cst) : (f32) -> !fir.type<t{x:f32}>
+  fir.save_result %res to %buffer : !fir.type<t{x:f32}>, !fir.ref<!fir.type<t{x:f32}>>
+
+  // GLOBAL-REF: %[[buffer:.*]] = fir.alloca !fir.type<t{x:f32}>
+  // GLOBAL-REF: %[[cst:.*]] = arith.constant {{.*}} : f32
+  // GLOBAL-REF: fir.call @derivedfunc_callee(%[[buffer]], %[[cst]]) : (!fir.ref<!fir.type<t{x:f32}>>, f32) -> ()
+  // GLOBAL-REF-NOT: fir.save_result
+
+  // GLOBAL-BOX: %[[buffer:.*]] = fir.alloca !fir.type<t{x:f32}>
+  // GLOBAL-BOX: %[[cst:.*]] = arith.constant {{.*}} : f32
+  // GLOBAL-BOX: %[[box:.*]] = fir.embox %[[buffer]] : (!fir.ref<!fir.type<t{x:f32}>>) -> !fir.box<!fir.type<t{x:f32}>>
+  // GLOBAL-BOX: fir.call @derivedfunc_callee(%[[box]], %[[cst]]) : (!fir.box<!fir.type<t{x:f32}>>, f32) -> ()
+  // GLOBAL-BOX-NOT: fir.save_result
+
+  %c42 = arith.constant 42 : i32
+  fir.has_value %c42 : i32
+}
+
+// GLOBAL-REF-LABEL: fir.global @global_call_boxfunc : i32 {
+// GLOBAL-BOX-LABEL: fir.global @global_call_boxfunc : i32 {
+fir.global @global_call_boxfunc : i32 {
+  %buffer = fir.alloca !fir.box<!fir.heap<f64>>
+  %res = fir.call @boxfunc_callee() : () -> !fir.box<!fir.heap<f64>>
+  fir.save_result %res to %buffer: !fir.box<!fir.heap<f64>>, !fir.ref<!fir.box<!fir.heap<f64>>>
+
+  // GLOBAL-REF: %[[buffer:.*]] = fir.alloca !fir.box<!fir.heap<f64>>
+  // GLOBAL-REF: fir.call @boxfunc_callee(%[[buffer]]) : (!fir.ref<!fir.box<!fir.heap<f64>>>) -> ()
+  // GLOBAL-REF-NOT: fir.save_result
+
+  // GLOBAL-BOX: %[[buffer:.*]] = fir.alloca !fir.box<!fir.heap<f64>>
+  // GLOBAL-BOX: fir.call @boxfunc_callee(%[[buffer]]) : (!fir.ref<!fir.box<!fir.heap<f64>>>) -> ()
+  // GLOBAL-BOX-NOT: fir.save_result
+
+  %c42 = arith.constant 42 : i32
+  fir.has_value %c42 : i32
+}
+
+// GLOBAL-REF-LABEL: fir.global @global_call_chararrayfunc : i32 {
+// GLOBAL-BOX-LABEL: fir.global @global_call_chararrayfunc : i32 {
+fir.global @global_call_chararrayfunc : i32 {
+  %c100 = arith.constant 100 : index
+  %c50 = arith.constant 50 : index
+  %buffer = fir.alloca !fir.array<?x!fir.char<1,?>>(%c100 : index), %c50
+  %shape = fir.shape %c100 : (index) -> !fir.shape<1>
+  %res = fir.call @chararrayfunc(%c100, %c50) : (index, index) -> !fir.array<?x!fir.char<1,?>>
+  fir.save_result %res to %buffer(%shape) typeparams %c50 : !fir.array<?x!fir.char<1,?>>, !fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index
+
+  // GLOBAL-REF: %[[c100:.*]] = arith.constant 100 : index
+  // GLOBAL-REF: %[[c50:.*]] = arith.constant 50 : index
+  // GLOBAL-REF: %[[buffer:.*]] = fir.alloca !fir.array<?x!fir.char<1,?>>(%[[c100]] : index), %[[c50]]
+  // GLOBAL-REF: fir.call @chararrayfunc(%[[buffer]], %[[c100]], %[[c50]]) : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, index, index) -> ()
+  // GLOBAL-REF-NOT: fir.save_result
+
+  // GLOBAL-BOX: %[[c100:.*]] = arith.constant 100 : index
+  // GLOBAL-BOX: %[[c50:.*]] = arith.constant 50 : index
+  // GLOBAL-BOX: %[[buffer:.*]] = fir.alloca !fir.array<?x!fir.char<1,?>>(%[[c100]] : index), %[[c50]]
+  // GLOBAL-BOX: %[[shape:.*]] = fir.shape %[[c100]] : (index) -> !fir.shape<1>
+  // GLOBAL-BOX: %[[box:.*]] = fir.embox %[[buffer]](%[[shape]]) typeparams %[[c50]] : (!fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.box<!fir.array<?x!fir.char<1,?>>>
+  // GLOBAL-BOX: fir.call @chararrayfunc(%[[box]], %[[c100]], %[[c50]]) : (!fir.box<!fir.array<?x!fir.char<1,?>>>, index, index) -> ()
+  // GLOBAL-BOX-NOT: fir.save_result
+
+  %c42 = arith.constant 42 : i32
+  fir.has_value %c42 : i32
+}
+
+// GLOBAL-REF-LABEL: fir.global @global_test_address_of : i32 {
+// GLOBAL-BOX-LABEL: fir.global @global_test_address_of : i32 {
+fir.global @global_test_address_of : i32 {
+  %0 = fir.address_of(@arrayfunc) : (i32) -> !fir.array<?xf32>
+  fir.call @takesfuncarray(%0) : ((i32) -> !fir.array<?xf32>) -> ()
+
+  // GLOBAL-REF: %[[addrOf:.*]] = fir.address_of(@arrayfunc) : (!fir.ref<!fir.array<?xf32>>, i32) -> ()
+  // GLOBAL-REF: %[[conv:.*]] = fir.convert %[[addrOf]] : ((!fir.ref<!fir.array<?xf32>>, i32) -> ()) -> ((i32) -> !fir.array<?xf32>)
+  // GLOBAL-REF: fir.call @takesfuncarray(%[[conv]]) : ((i32) -> !fir.array<?xf32>) -> ()
+
+  // GLOBAL-BOX: %[[addrOf:.*]] = fir.address_of(@arrayfunc) : (!fir.box<!fir.array<?xf32>>, i32) -> ()
+  // GLOBAL-BOX: %[[conv:.*]] = fir.convert %[[addrOf]] : ((!fir.box<!fir.array<?xf32>>, i32) -> ()) -> ((i32) -> !fir.array<?xf32>)
+  // GLOBAL-BOX: fir.call @takesfuncarray(%[[conv]]) : ((i32) -> !fir.array<?xf32>) -> ()
+
+  %c42 = arith.constant 42 : i32
+  fir.has_value %c42 : i32
+}
diff --git a/flang/test/Fir/basic-program.fir b/flang/test/Fir/basic-program.fir
--- a/flang/test/Fir/basic-program.fir
+++ b/flang/test/Fir/basic-program.fir
@@ -50,8 +50,11 @@
 // PASSES-NEXT:   (S) 0 num-dce'd - Number of operations DCE'd
 // PASSES-NEXT: BoxedProcedurePass
 
-// PASSES-NEXT: 'func.func' Pipeline
-// PASSES-NEXT:   AbstractResultOnFuncOpt
+// PASSES-NEXT: Pipeline Collection : ['fir.global', 'func.func']
+// PASSES-NEXT:   'fir.global' Pipeline
+// PASSES-NEXT:    AbstractResultOnGlobalOpt
+// PASSES-NEXT:  'func.func' Pipeline
+// PASSES-NEXT:    AbstractResultOnFuncOpt
 
 // PASSES-NEXT: CodeGenRewrite
 // PASSES-NEXT:   (S) 0 num-dce'd - Number of operations eliminated