[Flang] Add -fconvert option to swap endianness for unformatted files

[jpenix-quic]

Summary

To accomplish this, this patch creates an optional list of environment
variable default values to be set by the runtime to allow directly using
the existing runtime implementation of FORT_CONVERT for I/O conversions.

Resolves issue: https://github.com/llvm/llvm-project/issues/55961

[jpenix-quic]

I do have a few related lingering questions as well:

1. While this implementation mimics gfortran's behavior, there are still differences with other compilers (please see the comment here: https://github.com/llvm/llvm-project/issues/55961#issuecomment-1175677659). Is there a good place to document this (if worthwhile)?
2. There are a few differences in how gfortran and this implementation prioritize the convert command line option, environment variable, and CONVERT= specifier (please see comment here https://github.com/llvm/llvm-project/issues/55961#issuecomment-1172547132). Would this be worthwhile to change to match gfortran as well? If not, is there maybe a good place to document this?

[klausler]

Instead of adding new custom APIs that let command-line options control behavior in a way that is redundant with the runtime environment, I suggest that you try a more general runtime library API by which the main program can specify a default environment variable setting, or a set of them. Then turn the command-line options into the equivalent environment settings and pass them as default settings that could be overridden by the actual environment.

This would not be any more work, it would lead to a cleaner implementation in the runtime than this one, and it would make the next option of this kind much easier to implement.

[klausler]

flang/runtime/main.cpp

53

We always use braces on if/for/while/&c. constructs in the runtime.

[jpenix-quic]

Thank you for taking a look at this and thank you for the feedback!

I'm not sure if I am entirely following/I think I am confusing myself on some of the specifics. My understanding of your suggestion is that, rather than add and create a call to a fconvert-specific runtime function (ConvertOption) I should look towards implementing and calling a runtime function/API that (conceptually) looks something like SetRuntimeDefaults(FORT_CONVERT="SWAP", [...]) to set whatever was specified on the command line.

I think where I'm getting confused is when you mention default environment variable settings or translating the command-line options into the equivalent environment settings and passing them as defaults: is the idea to set the actual (in this case) FORT_CONVERT environment variable if it hasn't already been defined in the environment, with the goal of letting the existing FORT_CONVERT handling deal with everything? Or, is directly setting the executionEnvironment.conversion value like I tried to do in ConvertOption ok, but I need to rethink the ConvertOption API itself? If the goal is to set FORT_CONVERT, I'm getting a bit hung up on FORT_CONVERT currently being handled as part of the "hardcoded" main in Fort_main.c.

[peixin]

clang/include/clang/Driver/Options.td

4938

Why do you move it here? Maybe it is not implemented now, clang may need this option eventually. @MaskRay

[jpenix-quic]

clang/include/clang/Driver/Options.td

4938

I was using the fixed line length options as a reference for how to handle this--based on the discussion in the review here (https://reviews.llvm.org/D95460) about forwarding options to gfortran, I was thinking that it would also be safe to handle fconvert similarly, but I'm not 100% sure and definitely might be misunderstanding something!

clang/lib/Driver/ToolChains/Flang.cpp

64

Reading through https://reviews.llvm.org/D95460 again, I'm not sure this is the appropriate place to add . I am marking this as a TODO that I will revisit with the other feedback!

[awarzynski]

Thanks for working on this. This is not my area of expertise, so I focused on the implementation in the driver.

clang/include/clang/Driver/Options.td

4938

GFortran support has been effectively broken since LLVM 12 (see e.g. this change). We would do ourselves a favor if we just removed it altogether (I'm not aware of anyone requiring it).

And if Clang ever needs this option, we can always update this definition accordingly. No need to optimize for hypothetical scenarios that may or may not happen :) To me, this change makes perfect sense.

clang/lib/Driver/ToolChains/Flang.cpp

64

You can use AddOtherOptions instead. AddFortranDialectOptions is more about language options. Is this a language option? It's a bit of a borderline. Feel free to add another hook too.

Btw, the reformatting is an unrelated change. Could you submit in a separate patch? Thanks!

[jpenix-quic]

Added changes to address feedback about missing braces and where I am adding options::OPT_fconvert_EQ (and removing the extra formatting change). Also removes an unnecessary include I had mistakenly added.

[jpenix-quic]

clang/lib/Driver/ToolChains/Flang.cpp

64

I went the AddOtherOptions route for now. Apologies for the unrelated change and thank you for checking over this!

[peixin]

Currently, I cannot test the option -fconvert=big-endian with open statement with convert argument using the following code since lowering is not supported. I am not sure if it can be tested in runtime.

$ cat fconvert_option_openfile.f90 
module fconvert_option_openfile

contains
  subroutine open_for_read(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='old')
  end
  subroutine open_for_read_BE(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='old', convert="BIG_ENDIAN")
  end
  subroutine open_for_read_LE(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='old', convert="LITTLE_ENDIAN")
  end
  subroutine open_for_read_native(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='old', convert="NATIVE")
  end

  subroutine open_for_write(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='new')
  end
  subroutine open_for_write_BE(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='new', convert="BIG_ENDIAN")
  end
  subroutine open_for_write_LE(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='new', convert="LITTLE_ENDIAN")
  end
  subroutine open_for_write_native(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='new', convert="NATIVE")
  end
end
$ cat fconvert_option_readfile.f90 
module fconvert_option_readfile

contains
  subroutine readfile(fid, del_flag, expect, n, t)
    integer :: n, t
    integer :: fid, del_flag
    real :: expect(n)
    real :: buf(n)

    read (fid) buf
    if (del_flag .eq. 0) then
      close (fid)
    else
      close (fid, status='delete')
    end if

    do i = 1, n
      if (buf(i) .ne. expect(i)) stop (i+t)
    enddo
  end
end
$ cat fconvert_option_main_1.f90 
program fconvert_option_main_1
  use fconvert_option_openfile
  use fconvert_option_readfile

  integer, parameter :: n = 4
  integer :: del_flag = 0 ! 1 for deleting data file after read
  real :: arr(n) = [1.0, 2.0, 3.0, 4.0]
  character(:), allocatable :: filename
  integer :: arglen

  call get_command_argument(1, length = arglen)
  allocate(character(arglen) :: filename)
  call get_command_argument(1, value = filename)

  call open_for_read(10, filename)
  call readfile(10, del_flag, arr, n, 0)

  call open_for_read_LE(11, filename)
  call readfile(11, del_flag, arr, n, 4)

  call open_for_read_native(12, filename)
  call readfile(12, del_flag, arr, n, 8)

  print *, 'PASS'
end

BTW, can you continue working on the lowering of the convert argument of open statement?

clang/include/clang/Driver/Options.td

4938

OK. This sounds reasonable to me.

flang/lib/Lower/Bridge.cpp

2902

I think this should be moved into void lowerFunc(Fortran::lower::pft::FunctionLikeUnit &funit).

flang/runtime/main.cpp

57

Nit: Is it better to to check the range of i before getting it from GetConvertFromInt?

if (i < static_cast<int>(Convert::Unknown) || i > static_cast<int>(Convert::Swap)) {
  crash
} else {
  Fortran::runtime::executionEnvironment.conversion = static_cast<Convert>(i);
}

60

Should __FILE__, __LINE__ be passed as argument in lowering to point to the file name and line of the source file? Or is this (FILE, LINE) pointing the the file name and line of the source file?

[jpenix-quic]

Attempted to address comments suggesting a different approach for the implementation. Rather than add a call to a new set_convert() runtime function, create a list of environment variable defaults that is passed into and set by the runtime via a "known" extern data structure. Also rebased.

[jpenix-quic]

BTW, can you continue working on the lowering of the convert argument of open statement?

I will take a look at this!

flang/lib/Lower/Bridge.cpp

2902

I ended moving this again while changing approaches--the equivalent line is above at lines 243-252. Does the new location seem reasonable? I had to add the bool to indirectly track if a main program was specified, but the new location seemed the most fitting to me.

flang/runtime/main.cpp

57

I ended up not needing GetConvertFromInt when reworking the approach, so this has been removed!

60

I removed this instance of __FILE__, __LINE__, but I added another similar one in environment.cpp line 33!

The error points to environment.cpp line 33 in the new revision. I'm not sure if this is the best way of handling it, but given that there isn't a Fortran source line associated with either the environment list or the old runtime call (and as I think both are closer to implementation details than user-facing features), pointing to the runtime file seemed like the least confusing option for the error location.

[jpenix-quic]

Hopefully fix Window's build errors by using the proper Windows-specific environment utilities (_putenv_s vs setenv).

[peixin]

flang/lib/Lower/Bridge.cpp

228

Doing this can avoid add one variable to the bridge.

[jpenix-quic]

Change hasMainProgram to be a local variable and update summary to reflect the new approach.

[jpenix-quic]

flang/lib/Lower/Bridge.cpp

228

Done! (Although, I added the isMainProgram() check/update to the lambda below as it is a member function of FunctionLikeUnit specifically--please let me know if this looks ok!)

[peixin]

This needs rebase.

flang/lib/Lower/Bridge.cpp

228

Yes.

[jpenix-quic]

Rebase to address conflicts, use string substitution blocks in my tests.

[jpenix-quic]

@klausler Could you please take a look at this again and let me know if it is more in line with your suggestion above?

[klausler]

I can't speak to the lowering or driver bits, but the runtime part looks pretty good to me.

flang/runtime/environment-default-list.h

2

If you want this header to be maximally portable C and C++, please observe the usage of other such headers, and use old-school C /*comments*/.

You could probably just use an 'int' for the item count and avoid some difficulty below, unless you expect a program to use billions of default environment settings.

[peixin]

This needs rebase. I failed to apply this patch due to conflict.

[jpenix-quic]

Fixed up/simplified environment-default-list.h (and associated tests/lowering) for C/C++ compatibility. Also cleaned up a declaration and a few autos in the lowering component. Rebased.

[jpenix-quic]

flang/runtime/environment-default-list.h

2

Done re: using an int!

Just to double check regarding C/C++ portability and looking at other headers, one that I was looking at was Decimal/decimal.h and the structs, etc. in that file are conditionally added to namespaces depending on whether it is C or C++. I was waffling on whether I should be doing that here though (I am not currently/was not previously) as keeping the type out of the namespace allows me to keep a consistent type/directly pass the pointer from Fortran_main.c to main.cpp/enviornment.cpp. But, as a result I'm also polluting the default namespace with EnvironmentDefaultList/Item for C++ code. Is how I have it currently ok, or would it be better to move the structs into namespaces for C++ and just cast to the correct type along the way? (Or, is there another option I am missing?)

[peixin]

$ cat fconvert_option_main_2.f90 
!
! Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
! See https://llvm.org/LICENSE.txt for license information.
! SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
!
! checking for I/O: testing read with -fconvert=big-endian.
! The convert argument of open function has prior claim over fconvert option.
! Only main program intentionally compiled with -fconvert=big-endian.

program fconvert_option_main_2
  use fconvert_option_openfile
  use fconvert_option_readfile

  integer, parameter :: n = 4
  integer :: del_flag = 0 ! 1 for deleting data file after read
  real :: arr(n) = [1.0, 2.0, 3.0, 4.0]
  character(:), allocatable :: filename
  integer :: arglen

  call get_command_argument(1, length = arglen)
  allocate(character(arglen) :: filename)
  call get_command_argument(1, value = filename)

  call open_for_read_LE(10, filename)
  call readfile(10, del_flag, arr, n, 0)

  call open_for_read_native(11, filename)
  call readfile(11, del_flag, arr, n, 4)

  print *, 'PASS'
end
$ cat fconvert_option_readfile.f90 
!
! Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
! See https://llvm.org/LICENSE.txt for license information.
! SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
!
! checking for I/O: readfile subroutine

module fconvert_option_readfile

contains
  subroutine readfile(fid, del_flag, expect, n, t)
    integer :: n, t
    integer :: fid, del_flag
    real :: expect(n)
    real :: buf(n)

    read (fid) buf
    if (del_flag .eq. 0) then
      close (fid)
    else
      close (fid, status='delete')
    end if

    do i = 1, n
      if (buf(i) .ne. expect(i)) stop (i+t)
    enddo
  end
end
$ cat fconvert_option_openfile.f90 
!
! Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
! See https://llvm.org/LICENSE.txt for license information.
! SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
!
! checking for I/O: openfile subroutines

module fconvert_option_openfile

contains
  subroutine open_for_read(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='old')
  end
  subroutine open_for_read_BE(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='old', convert="BIG_ENDIAN")
  end
  subroutine open_for_read_LE(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='old', convert="LITTLE_ENDIAN")
  end
  subroutine open_for_read_native(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='old', convert="NATIVE")
  end

  subroutine open_for_write(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='new')
  end
  subroutine open_for_write_BE(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='new', convert="BIG_ENDIAN")
  end
  subroutine open_for_write_LE(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='new', convert="LITTLE_ENDIAN")
  end
  subroutine open_for_write_native(fid, file_name)
    integer :: fid
    character(:), allocatable :: file_name
    open (fid, file=file_name, form='UNFORMATTED', status='new', convert="NATIVE")
  end
end
$ cat fconvert_option_writefile.f90 
!
! Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
! See https://llvm.org/LICENSE.txt for license information.
! SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
!
! checking for I/O: writefile subroutine

module fconvert_option_writefile

contains
  subroutine writefile(fid, buf, n)
    integer :: n
    real :: buf(n)
    integer :: fid

    write (fid) buf
    close (fid)
  end
end
$ cat run.sh 
#!/bin/bash

echo "---------- gfortran ----------"
gfortran fconvert_option_readfile.f90 -c
gfortran fconvert_option_openfile.f90 -c
gfortran fconvert_option_writefile.f90 -c
gfortran $1.f90 $2 -c
gfortran $1.o fconvert_option_readfile.o fconvert_option_openfile.o fconvert_option_writefile.o
./a.out Inputs/fc_opt_data_$3 && rm *.o *.mod a.out

echo && echo "---------- flang-new ----------"
flang-new fconvert_option_readfile.f90 -c
flang-new fconvert_option_openfile.f90 -c
flang-new fconvert_option_writefile.f90 -c
flang-new $1.f90 $2 -c
flang-new -flang-experimental-exec $1.o fconvert_option_readfile.o fconvert_option_openfile.o fconvert_option_writefile.o 
./a.out Inputs/fc_opt_data_$3 && rm *.o *.mod a.out

$ bash run.sh fconvert_option_main_2 -fconvert=big-endian little
---------- gfortran ----------
 PASS

---------- flang-new ----------

fatal Fortran runtime error(./fconvert_option_readfile.f90:17): Unformatted variable-length sequential file input failed at record #1 (file offset 0): hit EOF reading record with length 268435456 bytes
run.sh: line 17: 126614 Aborted                 (core dumped) ./a.out Inputs/fc_opt_data_$3

Not sure if this fail is caused by this patch or runtime IO functions. I will add our other internal tests to https://github.com/llvm/llvm-project/issues/55961 later and you can also test those cases. The data is an array of "1.0 2.0 3.0 4.0" through little-endian or big-endian. You can create it by yourself.

[peixin]

Mostly LGTM. Have several more comments.

flang/lib/Lower/Bridge.cpp

274

Nit

flang/lib/Optimizer/Builder/Runtime/EnvironmentDefaults.cpp

20

if (builder.getNamedGlobal(envDefaultListPtrName))
  return;

I don't think this and doEnvironmentDefaultList are necessary.

flang/test/Driver/emit-mlir.f90

16

Is it possible not to generated this global variable if fconvert= is not specified?

[jpenix-quic]

flang/test/Driver/emit-mlir.f90

16

I'm not entirely sure--the issue I was running into was how to handle this in Fortran_main.c in a way which worked for all of GCC/Clang/Visual Studio (and maybe others?). I was originally thinking of doing this by using a weak definition of _QQEnvironmentDefaults set to nullptr so fconvert, etc. could override this definition without explicitly generating the fallback case. For GCC/clang, I think I could use attribute((weak)), but I wasn't sure how to handle this if someone tried to build with Visual Studio (or maybe another toolchain). I saw a few workarounds (ex: https://devblogs.microsoft.com/oldnewthing/20200731-00/?p=104024) but I shied away from this since it seems to be an undocumented feature (and presumably only helps with Visual Studio).

Do you know of a better or more general way I could do this? (Or, is there non-weak symbol approach that might be better that I'm missing?)

[peixin]

flang/runtime/environment.cpp

77

What is environ used for? Should we try to keep as less extern variable as possible in runtime for security.

flang/test/Driver/emit-mlir.f90

16

How about generate one runtime function with the argument of EnvironmentDefaultList? This will avoid this and using one extern variable?

If users use one variable with bind C name _QQEnvironmentDefaults in fortran or one variable with name _QQEnvironmentDefaults in C, it is risky. Would using the runtime function and static variable with the type EnvironmentDefaultList in runtime be safer?

[jpenix-quic]

Remove unneeded braces and unnecessary changes to NameUniquer.

[jpenix-quic]

flang/runtime/environment.cpp

77

I think setenv is only required to make sure that the environ pointer points to the correct copy of the environment variables. So, as long as we are storing a copy of the environment pointer in ExecutionEnvironment and potentially making changes to the environment via setenv, I think we need to base it off the environ pointer after setenv has been called rather than the envp from main.

That said, I don't think the envp variable we are storing is being used for anything at the moment (reading environment variables was changed to use getenv rather than envp in the commit here). If removing the usage of environ is preferable, we could maybe remove the usage of envp altogether (in a separate patch)--does this sound like a good idea or would it be better to just leave in the environ usage for now?

flang/test/Driver/emit-mlir.f90

16

Agreed that there are potential risks with the current approach (although, are the _Q* names considered reserved?). Unfortunately, I think generating a call to set the environment defaults requires somewhat significant changes to the runtime. The runtime reads environment variables during initialization in ExecutionEnvironment::Configure which is ultimately called from the "hardcoded" Fortran_main.c and I need to set the defaults before this happens. So, I believe I'd either have to move the initialization to _QQmain or make it so that main isn't hardcoded so that I could insert the appropriate runtime function.

@klausler I think I asked you about this when I was first trying to figure out how to implement the environment defaults and you suggested I try the extern approach--please let me know if you have thoughts/suggestions around this!

[peixin]

flang/runtime/environment.cpp

77

Thanks for the explanations. The current fix makes sense to me.

flang/test/Driver/emit-mlir.f90

16

This is what @klausler suggested:

Instead of adding new custom APIs that let command-line options control behavior in a way that is redundant with the runtime environment, I suggest that you try a more general runtime library API by which the main program can specify a default environment variable setting, or a set of them. Then turn the command-line options into the equivalent environment settings and pass them as default settings that could be overridden by the actual environment.

If I understand correctly, what I am suggesting match his comments. The "main program" he means should be fortran main program, not the RTNAME(ProgramStart. In your initial patch, you add the runtime specified for "convert option". I think @klausler suggest you making the runtime argument more general used for a set of runtime environment variable settings, not restricted to "convert option". And that is what you already added -- EnvironmentDefaultList. So, combining this patch and your initial patch will be the solution. Hope I understand it correctly.

[jpenix-quic]

flang/test/Driver/emit-mlir.f90

16

The issue I hit with the suggested approach is that in order to use the pre-existing runtime environment variable handling to set the internal state I need to set the environment variable defaults before the environment variables are read by the runtime.

I might be misunderstanding/missing something, but given that the environment variables are read as part of RTNAME(ProgramStart) in main and the earliest I can place the call if I am generating it is _QQmain, I think that leaves three options: 1. don't hardcode main so that I can place the call early enough 2. delay or rerun the code here that is responsible for initializing the runtime state so that it is called as part of _QQmain so I can insert my runtime function before it or 3. hardcode something like the _QQEnvironmentDefaults into Fortran_main.c so that the environment defaults are available early enough. Option 2 seems less than ideal to me, option 1 seems ideal but requires generating main, so option 3 is what I ended up going with. If options 1 or 2 would be preferable to what is currently implemented (or if there is another possibility I'm missing!) I'd be happy to switch and try to implement them.

[peixin]

flang/test/Driver/emit-mlir.f90

16

What do other reviewers think? @klausler @awarzynski @kiranchandramohan @clementval @jeanPerier
The current approach has two drawbacks:

1. Add one extern variable _QQEnvironmentDefaults in runtime.
2. Generate the variable during lowering even if there is no -fconvert option.

Can we accept this?

[awarzynski]

flang/include/flang/Optimizer/Builder/Runtime/EnvironmentDefaults.h

8

Could you document what these are? And what are they used for?

flang/lib/Frontend/CompilerInvocation.cpp

414–424

I'm OK with a lambda here, just pointing our that in other cases we added small hooks, e.g. getOptimizationLevel. I personally prefer hooks as this means that methods like parseFrontendArgs can be a bit shorter. But this is a very weak preference!

flang/test/Driver/convert.f90

2

Could you be more specific? IIUC, this is more about making sure that the option parser works correctly and reports invalid usage of -fconvert as an error, right?

flang/test/Driver/emit-mlir.f90

16

Based on the analysis by @jpenix-quic, this is the path of least resistance and SGTM. It can always be refactored/improved in the future if need be. It would be helpful if this was documented somewhere. But I'm not sure whether there's a good landing space for this ATM.

flang/test/Lower/environment-defaults.f90

2

Can you test with flang-new as well?

[rovka]

IMO this is a reasonable approach, I only have a few nits.

flang/runtime/environment.cpp

42

77

I agree that we should remove envp altogether in a follow-up patch. As it stands it's just causing confusion.

flang/test/Driver/convert.f90

2

Nit: Shouldn't you also check that valid values (e.g. unknown, swap etc) are accepted?

flang/test/Driver/driver-help.f90

27

Nit: Why is there an extra blank for these?

[peixin]

flang/test/Driver/emit-mlir.f90

16

How about adding FIXME when generating the variables during lowering (flang/lib/Lower/Bridge.cpp).

[jpenix-quic]

Address comments from @awarzynski, @rovka, and @peixin. Also fixed the file header comments for EnvironmentDefaults.h, environment-defaults.h, and environment-default-list.h to match others in their respective folders.

[jpenix-quic]

Move comment, see if build will cooperate.

[jpenix-quic]

flang/test/Driver/convert.f90

2

Nit: Shouldn't you also check that valid values (e.g. unknown, swap etc) are accepted?

I might be doing something silly/missing something obvious, but I wasn't sure how to get FileCheck to basically just check that the command didn't error without adding checks, so I added trivial checks (VALID/VALID_FC1) for each of unknown/native/etc. Is there a better way of doing this? I also expanded flang/test/Lower/convert.f90 to check lowering for each of the valid options, so I didn't want to do full checks of the MLIR here.

[peixin]

The build still fails.

[jpenix-quic]

The build still fails.

I think it might be an infrastructure issue or something like that--I've tried restarting it a few times and each time it just ends with "HTTP 28" as the only message I see. Another review that was created a bit ago (https://reviews.llvm.org/D134329) seems to have the same issue, so I'll try restarting it again in a while.

[peixin]

In D130513#3804659, @jpenix-quic wrote:

The build still fails.

I think it might be an infrastructure issue or something like that--I've tried restarting it a few times and each time it just ends with "HTTP 28" as the only message I see. Another review that was created a bit ago (https://reviews.llvm.org/D134329) seems to have the same issue, so I'll try restarting it again in a while.

All the new created reviews fail for the same reason. https://reviews.llvm.org/harbormaster. You may need to wait for some time to restart it.

[peixin]

LGTM. Tested on one little-endian machine with our internal tests (I attached them in the issue https://github.com/llvm/llvm-project/issues/55961) for the priority of -fconvert= option and CONVERT argument in open statement and all passed. I didn't see the the GFORTRAN_CONVERT_UNIT used in HPC workloads and don't have tests for it. For now, I would avoid full combination tests for it.

@jeanPerier @clementval Can you help double check the lowering part?

[rovka]

flang/test/Driver/convert.f90

2

Just in case it's not clear, this looks good to me now, it's exactly what I had in mind.

[jeanPerier]

The lowering part looks good to me (I only have a minor comment inlined about a header used in lowering).

flang/include/flang/Runtime/environment-defaults.h

19 ↗

(On Diff #461759)

I think this header may better belong to Semantics (or even Lower since it is only used there) in the sense that it does not define a data structure that is used at runtime, but it defines a data structure so that we can keep track of some default environment value during compilation (It is not a huge deal, but I am a little bit wary of seeing std::string in Fortran::runtime while the runtime is meant to be free of the C++ runtime).

[jpenix-quic]

Add /*overwrite=*/ comment I missed previously, move Runtime/environment-defaults.h to Lower/EnvironmentDefault.h

[jpenix-quic]

In D130513#3827108, @jeanPerier wrote:

The lowering part looks good to me (I only have a minor comment inlined about a header used in lowering).

Thank you @jeanPerier for looking over the lowering portion! Regarding moving the header (I'm replying to the comment here since the inline one now opens in a separate revision/window as the file is gone), I moved it to Lower/EnvironmentDefault.h as lowering is where I use it (as you mentioned). Please let me know if this needs further changes!

Just to confirm/as a final check, @awarzynski does the driver portion look good to you? Similarly, @klausler does the runtime portion look good to you? I believe I addressed the comments you both left previously, but I want to make sure that I addressed things appropriately. Thanks!

[jeanPerier]

In D130513#3832241, @jpenix-quic wrote:

Thank you @jeanPerier for looking over the lowering portion! Regarding moving the header (I'm replying to the comment here since the inline one now opens in a separate revision/window as the file is gone), I moved it to Lower/EnvironmentDefault.h as lowering is where I use it (as you mentioned). Please let me know if this needs further changes!

LGTM, thanks.

[jpenix-quic]

Ping @awarzynski and @klausler --could you please let me know if the driver and runtime portions look good to you, respectively? (Apologies in advance if this isn't necessary, but as you both gave me significant feedback I wanted to make sure you are ok with the patch as it stands.) Thanks!

[klausler]

The runtime parts look good to me.

[awarzynski]

The driver looks good, thanks for all the effort!

[jpenix-quic]

0ec3ac9b7fbd

Gah, I goofed and forgot to add the "Differential Revision" line--this has been committed at 0ec3ac9b7fbd15698af7289e1214e8ff3d82ec14.

clang/include/clang/Driver/Options.td

 // Generic gfortran options.
 def A_DASH : Joined<["-"], "A-">, Group<gfortran_Group>;
 def static_libgfortran : Flag<["-"], "static-libgfortran">, Group<gfortran_Group>;
 
 // "f" options with values for gfortran.
 def fblas_matmul_limit_EQ : Joined<["-"], "fblas-matmul-limit=">, Group<gfortran_Group>;
 def fcheck_EQ : Joined<["-"], "fcheck=">, Group<gfortran_Group>;
 def fcoarray_EQ : Joined<["-"], "fcoarray=">, Group<gfortran_Group>;
-def fconvert_EQ : Joined<["-"], "fconvert=">, Group<gfortran_Group>;
 def ffpe_trap_EQ : Joined<["-"], "ffpe-trap=">, Group<gfortran_Group>;
 def ffree_line_length_VALUE : Joined<["-"], "ffree-line-length-">, Group<gfortran_Group>;
 def finit_character_EQ : Joined<["-"], "finit-character=">, Group<gfortran_Group>;
 def finit_integer_EQ : Joined<["-"], "finit-integer=">, Group<gfortran_Group>;
 def finit_logical_EQ : Joined<["-"], "finit-logical=">, Group<gfortran_Group>;
 def finit_real_EQ : Joined<["-"], "finit-real=">, Group<gfortran_Group>;
 def fmax_array_constructor_EQ : Joined<["-"], "fmax-array-constructor=">, Group<gfortran_Group>;
 def fmax_errors_EQ : Joined<["-"], "fmax-errors=">, Group<gfortran_Group>;
def ffixed_form : Flag<["-"], "ffixed-form">, Group<f_Group>,
   HelpText<"Process source files in fixed form">;
 def ffree_form : Flag<["-"], "ffree-form">, Group<f_Group>,
   HelpText<"Process source files in free form">;
 def ffixed_line_length_EQ : Joined<["-"], "ffixed-line-length=">, Group<f_Group>,
   HelpText<"Use <value> as character line width in fixed mode">,
   DocBrief<[{Set column after which characters are ignored in typical fixed-form lines in the source
 file}]>;
 def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<f_Group>, Alias<ffixed_line_length_EQ>;
+def fconvert_EQ : Joined<["-"], "fconvert=">, Group<f_Group>,
+  HelpText<"Set endian conversion of data for unformatted files">;
 def fopenacc : Flag<["-"], "fopenacc">, Group<f_Group>,
   HelpText<"Enable OpenACC">;
 def fdefault_double_8 : Flag<["-"],"fdefault-double-8">, Group<f_Group>,
   HelpText<"Set the default double precision kind to an 8 byte wide type">;
 def fdefault_integer_8 : Flag<["-"],"fdefault-integer-8">, Group<f_Group>,
   HelpText<"Set the default integer kind to an 8 byte wide type">;
 def fdefault_real_8 : Flag<["-"],"fdefault-real-8">, Group<f_Group>,
   HelpText<"Set the default real kind to an 8 byte wide type">;

clang/lib/Driver/ToolChains/Flang.cpp

Args.AddAllArgs(CmdArgs,
                   {options::OPT_P, options::OPT_D, options::OPT_U,
                    options::OPT_I, options::OPT_cpp, options::OPT_nocpp});
 }
 
 void Flang::AddOtherOptions(const ArgList &Args, ArgStringList &CmdArgs) const {
   Args.AddAllArgs(CmdArgs,
                   {options::OPT_module_dir, options::OPT_fdebug_module_writer,
                    options::OPT_fintrinsic_modules_path, options::OPT_pedantic,
-                   options::OPT_std_EQ, options::OPT_W_Joined});
+                   options::OPT_std_EQ, options::OPT_W_Joined,
+                   options::OPT_fconvert_EQ});
 }
 
 void Flang::AddPicOptions(const ArgList &Args, ArgStringList &CmdArgs) const {
   // ParsePICArgs parses -fPIC/-fPIE and their variants and returns a tuple of
   // (RelocationModel, PICLevel, IsPIE).
   llvm::Reloc::Model RelocationModel;
   unsigned PICLevel;
   bool IsPIE;
   std::tie(RelocationModel, PICLevel, IsPIE) =
       ParsePICArgs(getToolChain(), Args);
 
   if (auto *RMName = RelocationModelName(RelocationModel)) {
     CmdArgs.push_back("-mrelocation-model");

flang/examples/external-hello.cpp

void input1() {
   io = IONAME(BeginExternalListOutput)();
   const char str[]{"Result:"};
   IONAME(OutputAscii)(io, str, std::strlen(str));
   IONAME(OutputInteger64)(io, n);
   IONAME(EndIoStatement)(io);
 }
 
 int main(int argc, const char *argv[], const char *envp[]) {
-  RTNAME(ProgramStart)(argc, argv, envp);
+  RTNAME(ProgramStart)(argc, argv, envp, nullptr);
   output1();
   input1();
   RTNAME(PauseStatement)();
   RTNAME(ProgramEndStatement)();
   return 0;
 }

flang/include/flang/Frontend/FrontendOptions.h

 //===- FrontendOptions.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_FRONTEND_FRONTENDOPTIONS_H
 #define FORTRAN_FRONTEND_FRONTENDOPTIONS_H
 
 #include "flang/Common/Fortran-features.h"
+#include "flang/Lower/EnvironmentDefault.h"
 #include "flang/Parser/characters.h"
 #include "flang/Parser/unparse.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cstdint>
 #include <string>
 
 namespace Fortran::frontend {
struct FrontendOptions {
   std::string outputFile;
 
   /// The frontend action to perform.
   frontend::ActionKind programAction = ParseSyntaxOnly;
 
   // The form to process files in, if specified.
   FortranForm fortranForm = FortranForm::Unknown;
 
+  // Default values for environment variables to be set by the runtime.
+  std::vector<Fortran::lower::EnvironmentDefault> envDefaults;
+
   // The column after which characters are ignored in fixed form lines in the
   // source file.
   int fixedFormColumns = 72;
 
   /// The input kind, either specified via -x argument or deduced from the input
   /// file name.
   InputKind dashX;
 

flang/include/flang/Lower/Bridge.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_BRIDGE_H
 #define FORTRAN_LOWER_BRIDGE_H
 
 #include "flang/Common/Fortran.h"
 #include "flang/Lower/AbstractConverter.h"
+#include "flang/Lower/EnvironmentDefault.h"
 #include "flang/Lower/LoweringOptions.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/BuiltinOps.h"
 
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
public:
   static LoweringBridge
   create(mlir::MLIRContext &ctx,
          Fortran::semantics::SemanticsContext &semanticsContext,
          const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
          const Fortran::evaluate::IntrinsicProcTable &intrinsics,
          const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
          const Fortran::parser::AllCookedSources &allCooked,
          llvm::StringRef triple, fir::KindMapping &kindMap,
-         const Fortran::lower::LoweringOptions &loweringOptions) {
+         const Fortran::lower::LoweringOptions &loweringOptions,
+         const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults) {
     return LoweringBridge(ctx, semanticsContext, defaultKinds, intrinsics,
                           targetCharacteristics, allCooked, triple, kindMap,
-                          loweringOptions);
+                          loweringOptions, envDefaults);
   }
 
   //===--------------------------------------------------------------------===//
   // Getters
   //===--------------------------------------------------------------------===//
 
   mlir::MLIRContext &getMLIRContext() { return context; }
 
public:
 
   /// Get the kind map.
   const fir::KindMapping &getKindMap() const { return kindMap; }
 
   const Fortran::lower::LoweringOptions &getLoweringOptions() const {
     return loweringOptions;
   }
 
+  const std::vector<Fortran::lower::EnvironmentDefault> &
+  getEnvironmentDefaults() const {
+    return envDefaults;
+  }
+
   /// Create a folding context. Careful: this is very expensive.
   Fortran::evaluate::FoldingContext createFoldingContext() const;
 
   Fortran::semantics::SemanticsContext &getSemanticsContext() const {
     return semanticsContext;
   }
 
   bool validModule() { return getModule(); }
private:
   explicit LoweringBridge(
       mlir::MLIRContext &ctx,
       Fortran::semantics::SemanticsContext &semanticsContext,
       const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
       const Fortran::evaluate::IntrinsicProcTable &intrinsics,
       const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
       const Fortran::parser::AllCookedSources &cooked, llvm::StringRef triple,
       fir::KindMapping &kindMap,
-      const Fortran::lower::LoweringOptions &loweringOptions);
+      const Fortran::lower::LoweringOptions &loweringOptions,
+      const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults);
   LoweringBridge() = delete;
   LoweringBridge(const LoweringBridge &) = delete;
 
   Fortran::semantics::SemanticsContext &semanticsContext;
   const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds;
   const Fortran::evaluate::IntrinsicProcTable &intrinsics;
   const Fortran::evaluate::TargetCharacteristics &targetCharacteristics;
   const Fortran::parser::AllCookedSources *cooked;
   mlir::MLIRContext &context;
   std::unique_ptr<mlir::ModuleOp> module;
   fir::KindMapping &kindMap;
   const Fortran::lower::LoweringOptions &loweringOptions;
+  const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults;
 };
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_BRIDGE_H

flang/include/flang/Lower/EnvironmentDefault.h

+//===-- Lower/EnvironmentDefault.h ------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_LOWER_ENVIRONMENTDEFAULT_H
+#define FORTRAN_LOWER_ENVIRONMENTDEFAULT_H
+
+#include <string>
+
+namespace Fortran::lower {
+
+struct EnvironmentDefault {
+  std::string varName;
+  std::string defaultValue;
+};
+
+} // namespace Fortran::lower
+
+#endif // FORTRAN_LOWER_ENVIRONMENTDEFAULT_H

flang/include/flang/Optimizer/Builder/Runtime/EnvironmentDefaults.h

+//===-- EnvironmentDefaults.h -----------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// EnvironmentDefaults is a list of default values for environment variables
+// that may be specified at compile time and set by the runtime during
+// program startup if the variable is not already present in the environment.
+// EnvironmentDefaults is intended to allow options controlled by environment
+// variables to also be set on the command line at compile time without needing
+// to define option-specific runtime calls or duplicate logic within the
+// runtime. For example, the -fconvert command line option is implemented in
+// terms of an default value for the FORT_CONVERT environment variable.
+
+#ifndef FORTRAN_OPTIMIZER_BUILDER_RUNTIME_ENVIRONMENTDEFAULTS_H
+#define FORTRAN_OPTIMIZER_BUILDER_RUNTIME_ENVIRONMENTDEFAULTS_H
+
+#include <vector>
+
+namespace fir {
+class FirOpBuilder;
+} // namespace fir
+
+namespace mlir {
+class Location;
+} // namespace mlir
+
+namespace Fortran::lower {
+struct EnvironmentDefault;
+} // namespace Fortran::lower
+
+namespace fir::runtime {
+
+/// Create the list of environment variable defaults for the runtime to set. The
+/// form of the generated list is defined in the runtime header file
+/// environment-default-list.h
+void genEnvironmentDefaults(
+    fir::FirOpBuilder &builder, mlir::Location loc,
+    const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults);
+
+} // namespace fir::runtime
+#endif // FORTRAN_OPTIMIZER_BUILDER_RUNTIME_ENVIRONMENTDEFAULTS_H

flang/include/flang/Runtime/main.h

 //===-- include/flang/Runtime/main.h ----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_RUNTIME_MAIN_H_
 #define FORTRAN_RUNTIME_MAIN_H_
 
 #include "flang/Runtime/c-or-cpp.h"
 #include "flang/Runtime/entry-names.h"
 
+struct EnvironmentDefaultList;
+
 FORTRAN_EXTERN_C_BEGIN
-void RTNAME(ProgramStart)(int, const char *[], const char *[]);
+void RTNAME(ProgramStart)(
+    int, const char *[], const char *[], const struct EnvironmentDefaultList *);
 void RTNAME(ByteswapOption)(void); // -byteswapio
 FORTRAN_EXTERN_C_END
 
 #endif // FORTRAN_RUNTIME_MAIN_H_

flang/lib/Frontend/CompilerInvocation.cpp

static void setUpFrontendBasedOnAction(FrontendOptions &opts) {
   if (opts.programAction == DebugDumpParsingLog)
     opts.instrumentedParse = true;
 
   if (opts.programAction == DebugDumpProvenance ||
       opts.programAction == Fortran::frontend::GetDefinition)
     opts.needProvenanceRangeToCharBlockMappings = true;
 }
 
+/// Parse the argument specified for the -fconvert=<value> option
+static std::optional<const char *> parseConvertArg(const char *s) {
+  return llvm::StringSwitch<std::optional<const char *>>(s)
+      .Case("unknown", "UNKNOWN")
+      .Case("native", "NATIVE")
+      .Case("little-endian", "LITTLE_ENDIAN")
+      .Case("big-endian", "BIG_ENDIAN")
+      .Case("swap", "SWAP")
+      .Default(std::nullopt);
+}
+
 static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
                               clang::DiagnosticsEngine &diags) {
   unsigned numErrorsBefore = diags.getNumErrors();
 
   // By default the frontend driver creates a ParseSyntaxOnly action.
   opts.programAction = ParseSyntaxOnly;
 
   // Treat multiple action options as an invocation error. Note that `clang
if (const auto *arg =
     } else if (columns < 7) {
       diags.Report(clang::diag::err_drv_small_columns)
           << arg->getOption().getName() << arg->getValue() << "7";
     } else {
       opts.fixedFormColumns = columns;
     }
   }
 
+  // Set conversion based on -fconvert=<value>
+  if (const auto *arg =
+          args.getLastArg(clang::driver::options::OPT_fconvert_EQ)) {
+    const char *argValue = arg->getValue();
+    if (auto convert = parseConvertArg(argValue))
+      opts.envDefaults.push_back({"FORT_CONVERT", *convert});
+    else
+      diags.Report(clang::diag::err_drv_invalid_value)
+          << arg->getAsString(args) << argValue;
+  }
+
   // -f{no-}implicit-none
   opts.features.Enable(
       Fortran::common::LanguageFeature::ImplicitNoneTypeAlways,
       args.hasFlag(clang::driver::options::OPT_fimplicit_none,
           clang::driver::options::OPT_fno_implicit_none, false));
 
   // -f{no-}backslash
   opts.features.Enable(Fortran::common::LanguageFeature::BackslashEscapes,
       args.hasFlag(clang::driver::options::OPT_fbackslash,

flang/lib/Frontend/FrontendActions.cpp

const common::IntrinsicTypeDefaultKinds &defKinds =
       ci.getInvocation().getSemanticsContext().defaultKinds();
   fir::KindMapping kindMap(mlirCtx.get(), llvm::ArrayRef<fir::KindTy>{
                                               fir::fromDefaultKinds(defKinds)});
   lower::LoweringBridge lb = Fortran::lower::LoweringBridge::create(
       *mlirCtx, ci.getInvocation().getSemanticsContext(), defKinds,
       ci.getInvocation().getSemanticsContext().intrinsics(),
       ci.getInvocation().getSemanticsContext().targetCharacteristics(),
       ci.getParsing().allCooked(), ci.getInvocation().getTargetOpts().triple,
-      kindMap, ci.getInvocation().getLoweringOpts());
+      kindMap, ci.getInvocation().getLoweringOpts(),
+      ci.getInvocation().getFrontendOpts().envDefaults);
 
   // Create a parse tree and lower it to FIR
   Fortran::parser::Program &parseTree{*ci.getParsing().parseTree()};
   lb.lower(parseTree, ci.getInvocation().getSemanticsContext());
   mlirModule = std::make_unique<mlir::ModuleOp>(lb.getModule());
 
   // run the default passes.
   mlir::PassManager pm(mlirCtx.get(), mlir::OpPassManager::Nesting::Implicit);

flang/lib/Lower/Bridge.cpp

 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Lower/Support/Utils.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Runtime/Character.h"
+#include "flang/Optimizer/Builder/Runtime/EnvironmentDefaults.h"
 #include "flang/Optimizer/Builder/Runtime/Ragged.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "flang/Optimizer/Support/InternalNames.h"
void run(Fortran::lower::pft::Program &pft) {
     // should have to suit all its usage in the compilation unit.
     lowerCommonBlocks(pft.getCommonBlocks());
 
     //  - Declare all functions that have definitions so that definition
     //    signatures prevail over call site signatures.
     //  - Define module variables and OpenMP/OpenACC declarative construct so
     //    that they are available before lowering any function that may use
     //    them.
+    bool hasMainProgram = false;
     for (Fortran::lower::pft::Program::Units &u : pft.getUnits()) {
       std::visit(Fortran::common::visitors{
                      [&](Fortran::lower::pft::FunctionLikeUnit &f) {
+                       if (f.isMainProgram())
+                         hasMainProgram = true;
                        declareFunction(f);
                      },
                      [&](Fortran::lower::pft::ModuleLikeUnit &m) {
                        lowerModuleDeclScope(m);
                        for (Fortran::lower::pft::FunctionLikeUnit &f :
                             m.nestedFunctions)
                          declareFunction(f);
                      },
for (Fortran::lower::pft::Program::Units &u : pft.getUnits()) {
           u);
     }
 
     /// Once all the code has been translated, create runtime type info
     /// global data structure for the derived types that have been
     /// processed.
     createGlobalOutsideOfFunctionLowering(
         [&]() { runtimeTypeInfoConverter.createTypeInfoGlobals(*this); });
+
+    // Create the list of any environment defaults for the runtime to set. The
+    // runtime default list is only created if there is a main program to ensure
+    // it only happens once and to provide consistent results if multiple files
+    // are compiled separately.
+    if (hasMainProgram)
+      createGlobalOutsideOfFunctionLowering([&]() {
+        // FIXME: Ideally, this would create a call to a runtime function
+        // accepting the list of environment defaults. That way, we would not
+        // need to add an extern pointer to the runtime and said pointer would
+        // not need to be generated even if no defaults are specified.
+        // However, generating main or changing when the runtime reads
+        // environment variables is required to do so.
+        fir::runtime::genEnvironmentDefaults(*builder, toLocation(),
+                                             bridge.getEnvironmentDefaults());
+      });
   }
 
   /// Declare a function.
   void declareFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     setCurrentPosition(funit.getStartingSourceLoc());
     for (int entryIndex = 0, last = funit.entryPointList.size();
          entryIndex < last; ++entryIndex) {
       funit.setActiveEntry(entryIndex);
if (callee.hasAlternateReturns()) {
       mlir::Type idxTy = builder->getIndexType();
       mlir::Value altResult =
           builder->createTemporary(loc, idxTy, toStringRef(symbol.name()));
       addSymbol(symbol, altResult);
       mlir::Value zero = builder->createIntegerConstant(loc, idxTy, 0);
       builder->create<fir::StoreOp>(loc, zero, altResult);
     }
 
     if (Fortran::lower::pft::Evaluation *alternateEntryEval =
             funit.getEntryEval())
       genFIRBranch(alternateEntryEval->lexicalSuccessor->block);
   }
 
   /// Create global blocks for the current function.  This eliminates the
   /// distinction between forward and backward targets when generating
   /// branches.  A block is "global" if it can be the target of a GOTO or
   /// other source code branch.  A block that can only be targeted by a

 Fortran::lower::LoweringBridge::LoweringBridge(
     mlir::MLIRContext &context,
     Fortran::semantics::SemanticsContext &semanticsContext,
     const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
     const Fortran::evaluate::IntrinsicProcTable &intrinsics,
     const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
     const Fortran::parser::AllCookedSources &cooked, llvm::StringRef triple,
     fir::KindMapping &kindMap,
-    const Fortran::lower::LoweringOptions &loweringOptions)
+    const Fortran::lower::LoweringOptions &loweringOptions,
+    const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults)
     : semanticsContext{semanticsContext}, defaultKinds{defaultKinds},
       intrinsics{intrinsics}, targetCharacteristics{targetCharacteristics},
       cooked{&cooked}, context{context}, kindMap{kindMap},
-      loweringOptions{loweringOptions} {
+      loweringOptions{loweringOptions}, envDefaults{envDefaults} {
   // Register the diagnostic handler.
   context.getDiagEngine().registerHandler([](mlir::Diagnostic &diag) {
     llvm::raw_ostream &os = llvm::errs();
     switch (diag.getSeverity()) {
     case mlir::DiagnosticSeverity::Error:
       os << "error: ";
       break;
     case mlir::DiagnosticSeverity::Remark:

flang/lib/Optimizer/Builder/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FIRBuilder
   BoxValue.cpp
   Character.cpp
   Complex.cpp
   DoLoopHelper.cpp
   FIRBuilder.cpp
   LowLevelIntrinsics.cpp
   MutableBox.cpp
   Runtime/Assign.cpp
   Runtime/Character.cpp
   Runtime/Command.cpp
   Runtime/Derived.cpp
+  Runtime/EnvironmentDefaults.cpp
   Runtime/Inquiry.cpp
   Runtime/Numeric.cpp
   Runtime/Ragged.cpp
   Runtime/Reduction.cpp
   Runtime/Stop.cpp
   Runtime/Transformational.cpp
 
   DEPENDS

flang/lib/Optimizer/Builder/Runtime/EnvironmentDefaults.cpp

+//===-- EnvironmentDefaults.cpp -------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Builder/Runtime/EnvironmentDefaults.h"
+#include "flang/Lower/EnvironmentDefault.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "llvm/ADT/ArrayRef.h"
+
+void fir::runtime::genEnvironmentDefaults(
+    fir::FirOpBuilder &builder, mlir::Location loc,
+    const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults) {
+  std::string envDefaultListPtrName =
+      fir::NameUniquer::doGenerated("EnvironmentDefaults");
+
+  mlir::MLIRContext *context = builder.getContext();
+  mlir::StringAttr linkOnce = builder.createLinkOnceLinkage();
+  mlir::IntegerType intTy = builder.getIntegerType(8 * sizeof(int));
+  fir::ReferenceType charRefTy =
+      fir::ReferenceType::get(builder.getIntegerType(8));
+  fir::SequenceType itemListTy = fir::SequenceType::get(
+      envDefaults.size(),
+      mlir::TupleType::get(context, {charRefTy, charRefTy}));
+  mlir::TupleType envDefaultListTy = mlir::TupleType::get(
+      context, {intTy, fir::ReferenceType::get(itemListTy)});
+  fir::ReferenceType envDefaultListRefTy =
+      fir::ReferenceType::get(envDefaultListTy);
+
+  // If no defaults were specified, initialize with a null pointer.
+  if (envDefaults.empty()) {
+    builder.createGlobalConstant(
+        loc, envDefaultListRefTy, envDefaultListPtrName,
+        [&](fir::FirOpBuilder &builder) {
+          mlir::Value nullVal =
+              builder.createNullConstant(loc, envDefaultListRefTy);
+          builder.create<fir::HasValueOp>(loc, nullVal);
+        });
+    return;
+  }
+
+  // Create the Item list.
+  mlir::IndexType idxTy = builder.getIndexType();
+  mlir::IntegerAttr zero = builder.getIntegerAttr(idxTy, 0);
+  mlir::IntegerAttr one = builder.getIntegerAttr(idxTy, 1);
+  std::string itemListName = envDefaultListPtrName + ".items";
+  auto listBuilder = [&](fir::FirOpBuilder &builder) {
+    mlir::Value list = builder.create<fir::UndefOp>(loc, itemListTy);
+    llvm::SmallVector<mlir::Attribute, 2> idx = {mlir::Attribute{},
+                                                 mlir::Attribute{}};
+    auto insertStringField = [&](const std::string &s,
+                                 llvm::ArrayRef<mlir::Attribute> idx) {
+      mlir::Value stringAddress = fir::getBase(
+          fir::factory::createStringLiteral(builder, loc, s + '\0'));
+      mlir::Value addr = builder.createConvert(loc, charRefTy, stringAddress);
+      return builder.create<fir::InsertValueOp>(loc, itemListTy, list, addr,
+                                                builder.getArrayAttr(idx));
+    };
+
+    size_t n = 0;
+    for (const Fortran::lower::EnvironmentDefault &def : envDefaults) {
+      idx[0] = builder.getIntegerAttr(idxTy, n);
+      idx[1] = zero;
+      list = insertStringField(def.varName, idx);
+      idx[1] = one;
+      list = insertStringField(def.defaultValue, idx);
+      ++n;
+    }
+    builder.create<fir::HasValueOp>(loc, list);
+  };
+  builder.createGlobalConstant(loc, itemListTy, itemListName, listBuilder,
+                               linkOnce);
+
+  // Define the EnviornmentDefaultList object.
+  auto envDefaultListBuilder = [&](fir::FirOpBuilder &builder) {
+    mlir::Value envDefaultList =
+        builder.create<fir::UndefOp>(loc, envDefaultListTy);
+    mlir::Value numItems =
+        builder.createIntegerConstant(loc, intTy, envDefaults.size());
+    envDefaultList = builder.create<fir::InsertValueOp>(
+        loc, envDefaultListTy, envDefaultList, numItems,
+        builder.getArrayAttr(zero));
+    fir::GlobalOp itemList = builder.getNamedGlobal(itemListName);
+    assert(itemList && "missing environment default list");
+    mlir::Value listAddr = builder.create<fir::AddrOfOp>(
+        loc, itemList.resultType(), itemList.getSymbol());
+    envDefaultList = builder.create<fir::InsertValueOp>(
+        loc, envDefaultListTy, envDefaultList, listAddr,
+        builder.getArrayAttr(one));
+    builder.create<fir::HasValueOp>(loc, envDefaultList);
+  };
+  fir::GlobalOp envDefaultList = builder.createGlobalConstant(
+      loc, envDefaultListTy, envDefaultListPtrName + ".list",
+      envDefaultListBuilder, linkOnce);
+
+  // Define the pointer to the list used by the runtime.
+  builder.createGlobalConstant(
+      loc, envDefaultListRefTy, envDefaultListPtrName,
+      [&](fir::FirOpBuilder &builder) {
+        mlir::Value addr = builder.create<fir::AddrOfOp>(
+            loc, envDefaultList.resultType(), envDefaultList.getSymbol());
+        builder.create<fir::HasValueOp>(loc, addr);
+      });
+}

flang/runtime/FortranMain/Fortran_main.c

 //===-- runtime/FortranMain/Fortran_main.c --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/main.h"
 #include "flang/Runtime/stop.h"
 
 /* main entry into PROGRAM */
 void _QQmain(void);
 
+extern const struct EnvironmentDefaultList *_QQEnvironmentDefaults;
+
 /* C main stub */
 int main(int argc, const char *argv[], const char *envp[]) {
-  RTNAME(ProgramStart)(argc, argv, envp);
+  RTNAME(ProgramStart)(argc, argv, envp, _QQEnvironmentDefaults);
   _QQmain();
   RTNAME(ProgramEndStatement)();
   return 0;
 }

flang/runtime/environment-default-list.h

+/*===-- runtime/environment-default-list.h --------------------------*- C -*-===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ * ===-----------------------------------------------------------------------===
+ */
+
+#ifndef FORTRAN_RUNTIME_ENVIRONMENT_DEFAULT_LIST_H_
+#define FORTRAN_RUNTIME_ENVIRONMENT_DEFAULT_LIST_H_
+
+/* Try to maintain C compatibility to make it easier to both define environment
+ * defaults in non-Fortran main programs as well as pass through the environment
+ * default list in C code.
+ */
+
+struct EnvironmentDefaultItem {
+  const char *name;
+  const char *value;
+};
+
+/* Default values for environment variables are packaged by lowering into an
+ * instance of this struct to be read and set by the runtime.
+ */
+struct EnvironmentDefaultList {
+  int numItems;
+  const struct EnvironmentDefaultItem *item;
+};
+
+#endif /* FORTRAN_RUNTIME_ENVIRONMENT_DEFAULT_LIST_H_ */

flang/runtime/environment.h

 //===-- runtime/environment.h -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_RUNTIME_ENVIRONMENT_H_
 #define FORTRAN_RUNTIME_ENVIRONMENT_H_
 
 #include "flang/Decimal/decimal.h"
 #include <optional>
 
+struct EnvironmentDefaultList;
+
 namespace Fortran::runtime {
 
 class Terminator;
 
 #if FLANG_BIG_ENDIAN
 constexpr bool isHostLittleEndian{false};
 #elif FLANG_LITTLE_ENDIAN
 constexpr bool isHostLittleEndian{true};
 #else
 #error host endianness is not known
 #endif
 
 // External unformatted I/O data conversions
 enum class Convert { Unknown, Native, LittleEndian, BigEndian, Swap };
 
 std::optional<Convert> GetConvertFromString(const char *, std::size_t);
 
 struct ExecutionEnvironment {
   constexpr ExecutionEnvironment(){};
-  void Configure(int argc, const char *argv[], const char *envp[]);
+  void Configure(int argc, const char *argv[], const char *envp[],
+      const EnvironmentDefaultList *envDefaults);
   const char *GetEnv(
       const char *name, std::size_t name_length, const Terminator &terminator);
 
   int argc{0};
   const char **argv{nullptr};
-  const char **envp{nullptr};
+  char **envp{nullptr};
 
   int listDirectedOutputLineLengthLimit{79}; // FORT_FMT_RECL
   enum decimal::FortranRounding defaultOutputRoundingMode{
       decimal::FortranRounding::RoundNearest}; // RP(==PN)
   Convert conversion{Convert::Unknown}; // FORT_CONVERT
   bool noStopMessage{false}; // NO_STOP_MESSAGE=1 inhibits "Fortran STOP"
   bool defaultUTF8{false}; // DEFAULT_UTF8
 };
 
 extern ExecutionEnvironment executionEnvironment;
 } // namespace Fortran::runtime
 
 #endif // FORTRAN_RUNTIME_ENVIRONMENT_H_

flang/runtime/environment.cpp

 //===-- runtime/environment.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "environment.h"
+#include "environment-default-list.h"
 #include "memory.h"
 #include "tools.h"
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 
+#ifdef _WIN32
+extern char **_environ;
+#else
+extern char **environ;
+#endif
+
 namespace Fortran::runtime {
 
 ExecutionEnvironment executionEnvironment;
 
+static void SetEnvironmentDefaults(const EnvironmentDefaultList *envDefaults) {
+  if (!envDefaults) {
+    return;
+  }
+
+  for (int itemIndex = 0; itemIndex < envDefaults->numItems; ++itemIndex) {
+    const char *name = envDefaults->item[itemIndex].name;
+    const char *value = envDefaults->item[itemIndex].value;
+#ifdef _WIN32
+    if (auto *x{std::getenv(name)}) {
+      continue;
+    }
+    if (_putenv_s(name, value) != 0) {
+#else
+    if (setenv(name, value, /*overwrite=*/0) == -1) {
+#endif
+      Fortran::runtime::Terminator{__FILE__, __LINE__}.Crash(
+          std::strerror(errno));
+    }
+  }
+}
+
 std::optional<Convert> GetConvertFromString(const char *x, std::size_t n) {
   static const char *keywords[]{
       "UNKNOWN", "NATIVE", "LITTLE_ENDIAN", "BIG_ENDIAN", "SWAP", nullptr};
   switch (IdentifyValue(x, n, keywords)) {
   case 0:
     return Convert::Unknown;
   case 1:
     return Convert::Native;
   case 2:
     return Convert::LittleEndian;
   case 3:
     return Convert::BigEndian;
   case 4:
     return Convert::Swap;
   default:
     return std::nullopt;
   }
 }
 
-void ExecutionEnvironment::Configure(
-    int ac, const char *av[], const char *env[]) {
+void ExecutionEnvironment::Configure(int ac, const char *av[],
+    const char *env[], const EnvironmentDefaultList *envDefaults) {
   argc = ac;
   argv = av;
-  envp = env;
+  SetEnvironmentDefaults(envDefaults);
+#ifdef _WIN32
+  envp = _environ;
+#else
+  envp = environ;
+#endif
   listDirectedOutputLineLengthLimit = 79; // PGI default
   defaultOutputRoundingMode =
       decimal::FortranRounding::RoundNearest; // RP(==RN)
   conversion = Convert::Unknown;
 
   if (auto *x{std::getenv("FORT_FMT_RECL")}) {
     char *end;
     auto n{std::strtol(x, &end, 10)};

flang/runtime/main.cpp

 #ifdef fesetround
   fesetround(FE_TONEAREST);
 #else
   std::fesetround(FE_TONEAREST);
 #endif
 }
 
 extern "C" {
-void RTNAME(ProgramStart)(int argc, const char *argv[], const char *envp[]) {
+void RTNAME(ProgramStart)(int argc, const char *argv[], const char *envp[],
+    const EnvironmentDefaultList *envDefaults) {
   std::atexit(Fortran::runtime::NotifyOtherImagesOfNormalEnd);
-  Fortran::runtime::executionEnvironment.Configure(argc, argv, envp);
+  Fortran::runtime::executionEnvironment.Configure(
+      argc, argv, envp, envDefaults);
   ConfigureFloatingPoint();
   // I/O is initialized on demand so that it works for non-Fortran main().
 }
 
 void RTNAME(ByteswapOption)() {
   if (Fortran::runtime::executionEnvironment.conversion ==
       Fortran::runtime::Convert::Unknown) {
     // The environment variable overrides the command-line option;
     // either of them take precedence over explicit OPEN(CONVERT=) specifiers.
     Fortran::runtime::executionEnvironment.conversion =
         Fortran::runtime::Convert::Swap;
   }
 }
 }

flang/test/Driver/convert.f90

+! Ensure argument -fconvert=<value> accepts all relevant options and produces an
+! error if an invalid value is specified. 
+
+!--------------------------
+! FLANG DRIVER (flang)
+!--------------------------
+! RUN: %flang -### -fconvert=unknown %s  2>&1 | FileCheck %s --check-prefix=VALID
+! RUN: %flang -### -fconvert=native %s  2>&1 | FileCheck %s --check-prefix=VALID
+! RUN: %flang -### -fconvert=little-endian %s  2>&1 | FileCheck %s --check-prefix=VALID
+! RUN: %flang -### -fconvert=big-endian %s  2>&1 | FileCheck %s --check-prefix=VALID
+! RUN: %flang -### -fconvert=swap %s  2>&1 | FileCheck %s --check-prefix=VALID
+! RUN: not %flang -fconvert=foobar %s  2>&1 | FileCheck %s --check-prefix=INVALID
+
+!-----------------------------------------
+! FRONTEND FLANG DRIVER (flang-new -fc1)
+!-----------------------------------------
+! RUN: %flang_fc1 -emit-mlir -fconvert=unknown %s -o - | FileCheck %s --check-prefix=VALID_FC1
+! RUN: %flang_fc1 -emit-mlir -fconvert=native %s -o - | FileCheck %s --check-prefix=VALID_FC1
+! RUN: %flang_fc1 -emit-mlir -fconvert=little-endian %s -o - | FileCheck %s --check-prefix=VALID_FC1
+! RUN: %flang_fc1 -emit-mlir -fconvert=big-endian %s -o - | FileCheck %s --check-prefix=VALID_FC1
+! RUN: %flang_fc1 -emit-mlir -fconvert=swap %s -o - | FileCheck %s --check-prefix=VALID_FC1
+! RUN: not %flang_fc1 -fconvert=foobar %s  2>&1 | FileCheck %s --check-prefix=INVALID
+
+! Only test that the command executes without error. Correct handling of each
+! option is handled in Lowering tests.
+! VALID: -fconvert
+! VALID_FC1: module
+
+! INVALID: error: invalid value 'foobar' in '-fconvert=foobar'

flang/test/Driver/driver-help-hidden.f90

 ! CHECK-NEXT: -c        Only run preprocess, compile, and assemble steps
 ! CHECK-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! CHECK-NEXT: -emit-llvm             Use the LLVM representation for assembler and object files
 ! CHECK-NEXT: -E        Only run the preprocessor
 ! CHECK-NEXT: -falternative-parameter-statement
 ! CHECK-NEXT: Enable the old style PARAMETER statement
 ! CHECK-NEXT: -fbackslash            Specify that backslash in string introduces an escape character
 ! CHECK-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
+! CHECK-NEXT: -fconvert=<value>      Set endian conversion of data for unformatted files
 ! CHECK-NEXT: -fdefault-double-8     Set the default double precision kind to an 8 byte wide type
 ! CHECK-NEXT: -fdefault-integer-8    Set the default integer kind to an 8 byte wide type
 ! CHECK-NEXT: -fdefault-real-8       Set the default real kind to an 8 byte wide type
 ! CHECK-NEXT: -ffixed-form           Process source files in fixed form
 ! CHECK-NEXT: -ffixed-line-length=<value>
 ! CHECK-NEXT: Use <value> as character line width in fixed mode
 ! CHECK-NEXT: -ffree-form            Process source files in free form
 ! CHECK-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements

flang/test/Driver/driver-help.f90

 ! HELP-NEXT: -c                     Only run preprocess, compile, and assemble steps
 ! HELP-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! HELP-NEXT: -emit-llvm             Use the LLVM representation for assembler and object files
 ! HELP-NEXT: -E                     Only run the preprocessor
 ! HELP-NEXT: -falternative-parameter-statement
 ! HELP-NEXT: Enable the old style PARAMETER statement
 ! HELP-NEXT: -fbackslash            Specify that backslash in string introduces an escape character
 ! HELP-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
+! HELP-NEXT: -fconvert=<value>      Set endian conversion of data for unformatted files
 ! HELP-NEXT: -fdefault-double-8     Set the default double precision kind to an 8 byte wide type
 ! HELP-NEXT: -fdefault-integer-8    Set the default integer kind to an 8 byte wide type
 ! HELP-NEXT: -fdefault-real-8       Set the default real kind to an 8 byte wide type
 ! HELP-NEXT: -ffixed-form           Process source files in fixed form
 ! HELP-NEXT: -ffixed-line-length=<value>
 ! HELP-NEXT: Use <value> as character line width in fixed mode
 ! HELP-NEXT: -ffree-form            Process source files in free form
 ! HELP-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements

 ! HELP-FC1-NEXT: -emit-llvm Use the LLVM representation for assembler and object files
 ! HELP-FC1-NEXT: -emit-mlir Build the parse tree, then lower it to MLIR
 ! HELP-FC1-NEXT: -emit-obj Emit native object files
 ! HELP-FC1-NEXT: -E                     Only run the preprocessor
 ! HELP-FC1-NEXT: -falternative-parameter-statement
 ! HELP-FC1-NEXT: Enable the old style PARAMETER statement
 ! HELP-FC1-NEXT: -fbackslash            Specify that backslash in string introduces an escape character
 ! HELP-FC1-NEXT: -fcolor-diagnostics     Enable colors in diagnostics
+! HELP-FC1-NEXT: -fconvert=<value>      Set endian conversion of data for unformatted files
 ! HELP-FC1-NEXT: -fdebug-dump-all       Dump symbols and the parse tree after the semantic checks
 ! HELP-FC1-NEXT: -fdebug-dump-parse-tree-no-sema
 ! HELP-FC1-NEXT:                        Dump the parse tree (skips the semantic checks)
 ! HELP-FC1-NEXT: -fdebug-dump-parse-tree Dump the parse tree
 ! HELP-FC1-NEXT: -fdebug-dump-parsing-log
 ! HELP-FC1-NEXT:                   Run instrumented parse and dump the parsing log
 ! HELP-FC1-NEXT: -fdebug-dump-pft        Dump the pre-fir parse tree
 ! HELP-FC1-NEXT: -fdebug-dump-provenance Dump provenance

flang/test/Driver/emit-mlir.f90

 ! Test the `-emit-mlir` option
 
 ! RUN: %flang_fc1 -emit-mlir %s -o - | FileCheck %s
 ! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
 
 ! Verify that an `.mlir` file is created when `-emit-mlir` is used. Do it in a temporary directory, which will be cleaned up by the
 ! LIT runner.
 ! RUN: rm -rf %t-dir && mkdir -p %t-dir && cd %t-dir
 ! RUN: cp %s .
 ! RUN: %flang_fc1 -emit-mlir emit-mlir.f90 && ls emit-mlir.mlir
 
 ! CHECK: module attributes {
 ! CHECK-LABEL: func @_QQmain() {
 ! CHECK-NEXT:  return
 ! CHECK-NEXT: }
+! CHECK-NEXT: fir.global @_QQEnvironmentDefaults constant : !fir.ref<tuple<i[[int_size:.*]], !fir.ref<!fir.array<0xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>> {
+! CHECK-NEXT:  %[[VAL_0:.*]] = fir.zero_bits !fir.ref<tuple<i[[int_size]], !fir.ref<!fir.array<0xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>>
+! CHECK-NEXT: fir.has_value  %[[VAL_0]] : !fir.ref<tuple<i[[int_size]], !fir.ref<!fir.array<0xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>>
+! CHECK-NEXT: }
 ! CHECK-NEXT: }
 
 end program

flang/test/Driver/frontend-forwarding.f90

 ! Test that flang-new forwards Flang frontend
 ! options to flang-new -fc1 as expected.
 
 ! RUN: %flang -fsyntax-only -### %s -o %t 2>&1 \
 ! RUN:     -finput-charset=utf-8 \
 ! RUN:     -fdefault-double-8 \
 ! RUN:     -fdefault-integer-8 \
 ! RUN:     -fdefault-real-8 \
 ! RUN:     -flarge-sizes \
+! RUN:     -fconvert=little-endian \
 ! RUN:     -mllvm -print-before-all\
 ! RUN:     -P \
 ! RUN:   | FileCheck %s
 
 ! CHECK: "-P"
 ! CHECK: "-finput-charset=utf-8"
 ! CHECK: "-fdefault-double-8"
 ! CHECK: "-fdefault-integer-8"
 ! CHECK: "-fdefault-real-8"
 ! CHECK: "-flarge-sizes"
+! CHECK: "-fconvert=little-endian"
 ! CHECK:  "-mllvm" "-print-before-all"

flang/test/Lower/convert.f90

+! RUN: %flang_fc1 -emit-fir -fconvert=unknown %s -o - | FileCheck %s --check-prefixes=ALL,UNKNOWN
+! RUN: %flang_fc1 -emit-fir -fconvert=native %s -o - | FileCheck %s --check-prefixes=ALL,NATIVE
+! RUN: %flang_fc1 -emit-fir -fconvert=little-endian %s -o - | FileCheck %s --check-prefixes=ALL,LITTLE_ENDIAN
+! RUN: %flang_fc1 -emit-fir -fconvert=big-endian %s -o - | FileCheck %s --check-prefixes=ALL,BIG_ENDIAN
+! RUN: %flang_fc1 -emit-fir -fconvert=swap %s -o - | FileCheck %s --check-prefixes=ALL,SWAP
+
+program test
+  continue
+end
+
+! Try to test that -fconvert=<value> flag results in a environment default list
+! with the FORT_CONVERT option correctly specified.
+
+! ALL: fir.global linkonce @_QQEnvironmentDefaults.items constant : !fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>> {
+! ALL: %[[VAL_0:.*]] = fir.undefined !fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>
+! ALL: %[[VAL_1:.*]] = fir.address_of(@[[FC_STR:.*]]) : !fir.ref<!fir.char<1,13>>
+! ALL: %[[VAL_3:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>
+! ALL: %[[VAL_4:.*]] = fir.insert_value %[[VAL_0]], %[[VAL_3]], [0 : index, 0 : index] : (!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>, !fir.ref<i8>) -> !fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>
+! ALL: %[[VAL_5:.*]] = fir.address_of(@[[OPT_STR:.*]]) : !fir.ref<!fir.char<1,[[OPT_STR_LEN:.*]]>>
+! ALL: %[[VAL_7:.*]] = fir.convert %[[VAL_5]] : (!fir.ref<!fir.char<1,[[OPT_STR_LEN]]>>) -> !fir.ref<i8>
+! ALL: %[[VAL_8:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_7]], [0 : index, 1 : index] : (!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>, !fir.ref<i8>) -> !fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>
+! ALL: fir.has_value %[[VAL_8]] : !fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>
+
+! ALL: fir.global linkonce @[[FC_STR]] constant : !fir.char<1,13> {
+! ALL: %[[VAL_0:.*]] = fir.string_lit "FORT_CONVERT\00"(13) : !fir.char<1,13>
+! ALL: fir.has_value %[[VAL_0]] : !fir.char<1,13>
+
+! ALL: fir.global linkonce @[[OPT_STR]] constant : !fir.char<1,[[OPT_STR_LEN]]> {
+! UNKNOWN: %[[VAL_0:.*]] = fir.string_lit "UNKNOWN\00"([[OPT_STR_LEN]]) : !fir.char<1,[[OPT_STR_LEN]]>
+! NATIVE: %[[VAL_0:.*]] = fir.string_lit "NATIVE\00"([[OPT_STR_LEN]]) : !fir.char<1,[[OPT_STR_LEN]]>
+! LITTLE_ENDIAN: %[[VAL_0:.*]] = fir.string_lit "LITTLE_ENDIAN\00"([[OPT_STR_LEN]]) : !fir.char<1,[[OPT_STR_LEN]]>
+! BIG_ENDIAN: %[[VAL_0:.*]] = fir.string_lit "BIG_ENDIAN\00"([[OPT_STR_LEN]]) : !fir.char<1,[[OPT_STR_LEN]]>
+! SWAP: %[[VAL_0:.*]] = fir.string_lit "SWAP\00"([[OPT_STR_LEN]]) : !fir.char<1,[[OPT_STR_LEN]]>
+! ALL: fir.has_value %[[VAL_0]] : !fir.char<1,[[OPT_STR_LEN]]>
+
+! ALL: fir.global linkonce @_QQEnvironmentDefaults.list constant : tuple<i[[int_size:.*]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>> {
+! ALL: %[[VAL_0:.*]] = fir.undefined tuple<i[[int_size]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>
+! ALL: %[[VAL_1:.*]] = arith.constant 1 : i[[int_size]]
+! ALL: %[[VAL_2:.*]] = fir.insert_value %[[VAL_0]], %[[VAL_1]], [0 : index] : (tuple<i[[int_size]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>, i[[int_size]]) -> tuple<i[[int_size]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>
+! ALL: %[[VAL_3:.*]] = fir.address_of(@_QQEnvironmentDefaults.items) : !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>
+! ALL: %[[VAL_4:.*]] = fir.insert_value %[[VAL_2]], %[[VAL_3]], [1 : index] : (tuple<i[[int_size]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>, !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>) -> tuple<i[[int_size]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>
+! ALL: fir.has_value %[[VAL_4]] : tuple<i[[int_size]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>
+
+! ALL: fir.global @_QQEnvironmentDefaults constant : !fir.ref<tuple<i[[int_size]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>> {
+! ALL: %[[VAL_0:.*]] = fir.address_of(@_QQEnvironmentDefaults.list) : !fir.ref<tuple<i[[int_size]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>>
+! ALL: fir.has_value %[[VAL_0]] : !fir.ref<tuple<i[[int_size]], !fir.ref<!fir.array<1xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>>

flang/test/Lower/environment-defaults.f90

+! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
+! RUN: bbc -emit-fir -o - %s | FileCheck %s
+
+program test
+  continue
+end
+
+! Test that a null pointer is generated for environment defaults if nothing is specified
+
+! CHECK: fir.global @_QQEnvironmentDefaults constant : !fir.ref<tuple<i[[int_size:.*]], !fir.ref<!fir.array<0xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>> {
+! CHECK:  %[[VAL_0:.*]] = fir.zero_bits !fir.ref<tuple<i[[int_size]], !fir.ref<!fir.array<0xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>>
+! CHECK: fir.has_value  %[[VAL_0]] : !fir.ref<tuple<i[[int_size]], !fir.ref<!fir.array<0xtuple<!fir.ref<i8>, !fir.ref<i8>>>>>>

flang/test/Runtime/no-cpp-dep.c

 #include "flang/Runtime/entry-names.h"
 #include <stdint.h>
 
 /*
 Manually add declarations for the runtime functions that we want to make sure
 we're testing. We can't include any headers directly since they likely contain
 C++ code that would explode here.
 */
+struct EnvironmentDefaultList;
 struct Descriptor;
 
 double RTNAME(CpuTime)();
 
-void RTNAME(ProgramStart)(int, const char *[], const char *[]);
+void RTNAME(ProgramStart)(
+    int, const char *[], const char *[], const struct EnvironmentDefaultList *);
 int32_t RTNAME(ArgumentCount)();
 int32_t RTNAME(GetCommandArgument)(int32_t, const struct Descriptor *,
     const struct Descriptor *, const struct Descriptor *);
 
 int main() {
   double x = RTNAME(CpuTime)();
-  RTNAME(ProgramStart)(0, 0, 0);
+  RTNAME(ProgramStart)(0, 0, 0, 0);
   int32_t c = RTNAME(ArgumentCount)();
   int32_t v = RTNAME(GetCommandArgument)(0, 0, 0, 0);
   return x + c + v;
 }

flang/tools/bbc/bbc.cpp

static mlir::LogicalResult convertFortranSourceToMLIR(
   auto &defKinds = semanticsContext.defaultKinds();
   fir::KindMapping kindMap(
       &ctx, llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   // Use default lowering options for bbc.
   Fortran::lower::LoweringOptions loweringOptions{};
   auto burnside = Fortran::lower::LoweringBridge::create(
       ctx, semanticsContext, defKinds, semanticsContext.intrinsics(),
       semanticsContext.targetCharacteristics(), parsing.allCooked(), "",
-      kindMap, loweringOptions);
+      kindMap, loweringOptions, {});
   burnside.lower(parseTree, semanticsContext);
   mlir::ModuleOp mlirModule = burnside.getModule();
   std::error_code ec;
   std::string outputName = outputFilename;
   if (!outputName.size())
     outputName = llvm::sys::path::stem(inputFilename).str().append(".mlir");
   llvm::raw_fd_ostream out(outputName, ec);
   if (ec)

flang/unittests/Runtime/CommandTest.cpp

if (descriptor->Allocate() != 0) {
     return nullptr;
   }
   return descriptor;
 }
 
 class CommandFixture : public ::testing::Test {
 protected:
   CommandFixture(int argc, const char *argv[]) {
-    RTNAME(ProgramStart)(argc, argv, {});
+    RTNAME(ProgramStart)(argc, argv, {}, {});
   }
 
   std::string GetPaddedStr(const char *text, std::size_t len) const {
     std::string res{text};
     assert(res.length() <= len && "No room to pad");
     res.append(len - res.length(), ' ');
     return res;
   }

flang/unittests/Runtime/Stop.cpp

 
 TEST(TestProgramEnd, StopTest) {
   EXPECT_EXIT(RTNAME(StopStatement)(), testing::ExitedWithCode(EXIT_SUCCESS),
       "Fortran STOP");
 }
 
 TEST(TestProgramEnd, StopTestNoStopMessage) {
   putenv(const_cast<char *>("NO_STOP_MESSAGE=1"));
-  Fortran::runtime::executionEnvironment.Configure(0, nullptr, nullptr);
+  Fortran::runtime::executionEnvironment.Configure(
+      0, nullptr, nullptr, nullptr);
   EXPECT_EXIT(
       RTNAME(StopStatement)(), testing::ExitedWithCode(EXIT_SUCCESS), "");
 }
 
 TEST(TestProgramEnd, StopMessageTest) {
   static const char *message{"bye bye"};
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                   /*isErrorStop=*/false, /*quiet=*/false),
TEST(TestProgramEnd, StopMessageTest) {
 
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                   /*isErrorStop=*/true, /*quiet=*/true),
       testing::ExitedWithCode(EXIT_FAILURE), "");
 }
 
 TEST(TestProgramEnd, NoStopMessageTest) {
   putenv(const_cast<char *>("NO_STOP_MESSAGE=1"));
-  Fortran::runtime::executionEnvironment.Configure(0, nullptr, nullptr);
+  Fortran::runtime::executionEnvironment.Configure(
+      0, nullptr, nullptr, nullptr);
   static const char *message{"bye bye"};
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                   /*isErrorStop=*/false, /*quiet=*/false),
       testing::ExitedWithCode(EXIT_SUCCESS), "bye bye");
 
   EXPECT_EXIT(RTNAME(StopStatementText)(message, std::strlen(message),
                   /*isErrorStop=*/false, /*quiet=*/true),
       testing::ExitedWithCode(EXIT_SUCCESS), "");