LLParser: add an argument for overriding data layout and do not check alloca addr space

[yaxunl]

Summary

Sometimes users do not specify data layout in LLVM assembly and let llc set the data layout by target triple after loading the LLVM assembly.

Currently the parser checks alloca address space no matter whether the LLVM assembly contains data layout definition, which causes false alarm since the default data layout does not contain the correct alloca address space.

The parser also calls verifier to check debug info and updating invalid debug info. Currently there is no way to let the verifier to check debug info only. If the verifier finds non-debug-info issues the parser will fail.

For llc, the fix is to remove the check of alloca addr space in the parser and disable updating debug info, and defer the updating of debug info and verification to be after setting data layout of the IR by target.

For other llvm tools, since they do not override data layout by target but instead can override data layout by a command line option, an argument for overriding data layout is added to the parser. In cases where data layout overriding is necessary for the parser, the data layout can be provided by command line.

[arsenm]

lib/AsmParser/LLParser.cpp

6181–6185

The idea was to remove this check from the parser entirely

lib/IR/Verifier.cpp

3210 ↗

(On Diff #128967)

s/stack/DataLayout alloca/

[yaxunl]

lib/AsmParser/LLParser.cpp

6181–6185

Removing this check will cause some lit tests to fail since the verifier output different error messages.

The error message from the parser is better since it contains line/column number. Should we keep the check if the assembly contains data layout definition?

lib/IR/Verifier.cpp

3210 ↗

(On Diff #128967)

will fix.

[arsenm]

lib/AsmParser/LLParser.cpp

6181–6185

I think that's less important. The verifier error will dump the instruction so it's not difficult to find anyway. I think changing the error depending on whether the datalayout is in the module already would be inconsistent

[yaxunl]

lib/AsmParser/LLParser.cpp

6181–6185

OK. Will remove this and update lit tests.

[yaxunl]

Removed check of alloca addr space from LLParser.

[arsenm]

include/llvm/IR/Verifier.h

101 ↗

(On Diff #128971)

I'm not sure I understand why this option is needed or to UpgradeDebugInfo. I would expect the datalayout to be set already by the time any verification is done

[yaxunl]

include/llvm/IR/Verifier.h

101 ↗

(On Diff #128971)

LLParser calls UpgradeDebugInfo, which calls verifyModule. At this point the datalayout has not been set yet. llc sets datalayout by target after parsing the IR.

[arsenm]

include/llvm/IR/Verifier.h

101 ↗

(On Diff #128971)

Why does UpgradeDebugInfo need a special second verify run? Is there an issue with just removing that and relying on the normal verify pass?

[yaxunl]

include/llvm/IR/Verifier.h

101 ↗

(On Diff #128971)

UpgradeDebugInfo checks if the module only contains debug info error or any other error. If the module only contains debug info error, then it reports the error. If the debug info version is outdated, it deletes the debug info. If the module contains other error, it will report fatal error.

LLParser calls UpgradeDebugInfo mainly to report debug info error and delete outdated debug info. However since UpgradeDeugInfo may be called by other functions which expect it to abort on invalid module.

[yaxunl]

Removed module verification from UpgradeDebugInfo. UpgradeDebugInfo only checks debug info.

[yaxunl]

include/llvm/IR/Verifier.h

101 ↗

(On Diff #128971)

I have updated the patch so that UpgradeDebugInfo only checks debug info. It still needs to check debug info because it needs to delete invalid debug info. Now it does not check non-debug-info issues. Please take a look. Thanks.

[yaxunl]

ping

[arsenm]

lib/IR/Verifier.cpp

214–216 ↗

(On Diff #129499)

This seems to just be stopping all error messages?

test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll

1 ↗

(On Diff #129499)

This is a test regression

[yaxunl]

lib/IR/Verifier.cpp

214–216 ↗

(On Diff #129499)

No. This will only stop checking of non-debug info and will not stop checking debug info. Since checking of debug info does not use this function but uses DebugInfoCheckFailed.

test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll

1 ↗

(On Diff #129499)

This test should pass since it only contains invalid debug info. After the parser removes the debug info, the IR is valid. There is a bug in verifier mistakenly treated debug info error as non-debug info error. (See change in Verifier.cpp line 4492 for the fix). After that bug is fixed, this test should pass.

[arsenm]

test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll

1 ↗

(On Diff #129499)

Can you fix this in a separate patch then?

[yaxunl]

test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll

1 ↗

(On Diff #129499)

will do.

[yaxunl]

test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll

1 ↗

(On Diff #129499)

Separated the fix to https://reviews.llvm.org/D42391

[yaxunl]

Separated a bug fix about verifier incorrectly treating debug info error as non-debug-info error to another review.

[yaxunl]

Add a command line option to llvm-as to allow set datalayout. Opt already has such option but has a bug. Fixed the bug so that it works properly.
Add lit tests for llvm-as/opt.

[yaxunl]

Add back a change dropped by accident.

[aprantl]

lib/IR/Verifier.cpp

214–216 ↗

(On Diff #129499)

Can you please elaborate on this? I'm afraid I didn't understand your explanation.

3239 ↗

(On Diff #131362)

Please move this change into a separate review, it looks like an orthogonal change and just makes this patch harder to understand.

[yaxunl]

lib/IR/Verifier.cpp

214–216 ↗

(On Diff #129499)

The verifier checks two types of issues:

1. debug info issues

2. non-debug info issues

with this change, when TreatBrokenDebugInfoAsError is set, the verifier will ignore non-debug-info issues and only check debug info issues.

This is necessary for LLParser. Because LLParser only wants to check debug info issues so that it can drop invalid debug info.

Checking of non-debug-info issues is deferred after parsing.

3239 ↗

(On Diff #131362)

will do.

[yaxunl]

Separate the diagnostic error message change to https://reviews.llvm.org/D42543

[aprantl]

lib/IR/Verifier.cpp

214–216 ↗

(On Diff #129499)

In what situation would LLParser want to not verify the non-metadata part of the IR?

[aprantl]

I think I need some more context here. Is it accurate description that you want to be able to have LLParser accept malformed/underspecified address spaces on allocas? Why do you want to do this? Is this for writing testcases only? Both llc and opt already take an option to disable the verifier for the purpose of writing testcases. Why does this not work for you?

[aprantl]

Note that in production environments (think: non-asserts builds of LLVM) we *always* want/must run the verifier on any external input. This is very important for correctness and even for security (imagine LLVM as a JIT compiler for example).

[arsenm]

In D41832#988124, @aprantl wrote:

I think I need some more context here. Is it accurate description that you want to be able to have LLParser accept malformed/underspecified address spaces on allocas? Why do you want to do this? Is this for writing testcases only? Both llc and opt already take an option to disable the verifier for the purpose of writing testcases. Why does this not work for you?

The problem is tools like llc/opt can set the triple/datalayout from the command line. The parser is only capable of validating based on whatever IR is in the parsed module, so there is an inconsistency in what is considered valid IR until the datalayout is set. The verifier needs to be run as a separate step from the parsing, so clients would need to be responsible for running the verifier after it's set the datalayout. This is an issue for any datalayout dependent properties checked by the verifier, which as far as I can tell today is the alloca address space, and non-integral pointer address spaces.

[aprantl]

It sounds like what we really want is a --disable-datalayout-verification option that specifically just disables that one check?

[arsenm]

In D41832#988150, @aprantl wrote:

It sounds like what we really want is a --disable-datalayout-verification option that specifically just disables that one check?

I don't think this should be an option. We want the tools to work correctly with the verifier without manual intervention. Alternatively the parser should accept the datalayout and ignore whatever is parsed in the module?

[aprantl]

You are saying that if a datalayout is specified on the command line, it should override what is in the file? That sounds very reasonable to me.

[arsenm]

In D41832#988192, @aprantl wrote:

You are saying that if a datalayout is specified on the command line, it should override what is in the file? That sounds very reasonable to me.

Yes. I think an earlier version of the patch did something like that, but it seemed cleaner to me to separate the verifier from the initial IR parsing

[aprantl]

Wouldn't it be better to move the M->setDataLayout(ClDataLayout); to before we run the Verifier? It seems like we should verify the module in the state that it will be eventually consumed.

[yaxunl]

Can we reach consensus on how to fix this issue?

Letting LLParser accept an optional datalayout parameter and use it to override the datalayout in LLVM IR is simpler and more straightforward. There will be no change in Verifier.

[yaxunl]

In D41832#988209, @aprantl wrote:

Wouldn't it be better to move the M->setDataLayout(ClDataLayout); to before we run the Verifier? It seems like we should verify the module in the state that it will be eventually consumed.

Doing that solely is not enough for fixing the issue, since LLParser already calls Verifier before that by itself. Unless we provide LLParser a correct datalayout to override the datalayout from the IR, the verification inside the LLParser itself will still fail.

[aprantl]

LLParser already calls Verifier before that by itself

I wonder if that is actually necessary. Are there any code paths that invoke LLParser and don't run the Verifier afterwards? If not, then it would make sense to change that.

[yaxunl]

In D41832#988226, @aprantl wrote:

LLParser already calls Verifier before that by itself

I wonder if that is actually necessary. Are there any code paths that invoke LLParser and don't run the Verifier afterwards? If not, then it would make sense to change that.

There are some llvm tools invoke LLParser but do not run the Verifier afterwards, e.g. lli, llvm-cat, llvm-diff, etc.

[aprantl]

Thanks for checking!

Based on this, we could either

• make it the responsibility of the Caller of LLParser to run the Verifier and update those tools to run the Verifier.
• or pass the override datalayout into LLParser so it can inject it before running the Verifier.

I personally don't like the idea of relaxing the Verifier / making it verify something that is not what is being fed into the later stages. (Feel free to try and convince me otherwise though :-)

[yaxunl]

In D41832#988288, @aprantl wrote:

Thanks for checking!

Based on this, we could either

• make it the responsibility of the Caller of LLParser to run the Verifier and update those tools to run the Verifier.
• or pass the override datalayout into LLParser so it can inject it before running the Verifier.

I personally don't like the idea of relaxing the Verifier / making it verify something that is not what is being fed into the later stages. (Feel free to try and convince me otherwise though :-)

If we don't want to modify Verifier, then the only choice is to add an option to LLParser to allow datalayout to be overridden. Then the verifier will see a valid IR.

By adding the option to LLParser, all the tools automatically get an option to override the datalayout, then minimal change is needed.

[yaxunl]

I tried to add a parameter to LLParser for overriding datalayout. However I encountered another issue for llc.

If target is not specified on llc command line, llc needs to parse the LLVM assembly to get the target. To parse the LLVM assembly, llc needs to pass the datalayout to LLParser first. However, it does not know the datalayout since it does not know the target.

It seems we have to go back the current approach, that is, let LLParser only checks debug info and ignores non-debug info. For those llvm tools which does not explicitly verify module after parsing, I can add explicit verification after parsing.

[aprantl]

If target is not specified on llc command line, llc needs to parse the LLVM assembly to get the target. To parse the LLVM assembly, llc needs to pass the datalayout to LLParser first. However, it does not know the datalayout since it does not know the target.
It seems we have to go back the current approach, that is, let LLParser only checks debug info and ignores non-debug info. For those llvm tools which does not explicitly verify module after parsing, I can add explicit verification after parsing.

What about the other option: Don't run the verifier in LLParser and instead ensure that every client of LLParser runs the verifier?
We could even have the LLParser return a wrapper akin to

class UnverifiedModule {
  Module *M;
public:
  Module *verify();
}

to force clients to verify.

[yaxunl]

In D41832#989171, @aprantl wrote:

If target is not specified on llc command line, llc needs to parse the LLVM assembly to get the target. To parse the LLVM assembly, llc needs to pass the datalayout to LLParser first. However, it does not know the datalayout since it does not know the target.
It seems we have to go back the current approach, that is, let LLParser only checks debug info and ignores non-debug info. For those llvm tools which does not explicitly verify module after parsing, I can add explicit verification after parsing.

What about the other option: Don't run the verifier in LLParser and instead ensure that every client of LLParser runs the verifier?
We could even have the LLParser return a wrapper akin to

class UnverifiedModule {
  Module *M;
public:
  Module *verify();
}

to force clients to verify.

The parser needs to drop the invalid debug info. To do that it needs to call the verifier to check whether the debug info is valid. Do we also want to move dropping invalid debug info out of parser?

[aprantl]

You are right. My mental model of how this works was a bit out of date. We separated verification and debug info stripping recently. Let's scrap that idea.

Let's go back to your previous statement:

If target is not specified on llc command line, llc needs to parse the LLVM assembly to get the target. To parse the LLVM assembly, llc needs to pass the datalayout to LLParser first. However, it does not know the datalayout since it does not know the target.

Can you elaborate this? The problem is when only a datalayout but no target is specified on the commandline? Could you pass the datalayout as a string and have LLParser parse it?

[yaxunl]

In D41832#989179, @aprantl wrote:

You are right. My mental model of how this works was a bit out of date. We separated verification and debug info stripping recently. Let's scrap that idea.

Let's go back to your previous statement:

If target is not specified on llc command line, llc needs to parse the LLVM assembly to get the target. To parse the LLVM assembly, llc needs to pass the datalayout to LLParser first. However, it does not know the datalayout since it does not know the target.

Can you elaborate this? The problem is when only a datalayout but no target is specified on the commandline? Could you pass the datalayout as a string and have LLParser parse it?

llc is different from opt or llvm-as beause llc always override the datalayout of the input module with the datalayout of the target. Because llc always creates TargetMachine, it knows the datalayout string by target. Therefore llc is not supposed to get datalayout string by command line option. Instead, it is supposed to get datalayout string by target.

If the user does not specify target on llc command line, llc is supposed to get the target from LLVM assembly, then use it to get the datalayout string through TargetMachine. However, that means it has to parse the LLVM assembly first, but it cannot. Because to parse the LLVM assembly it needs to know the datalayout string first.

Of course, if we specify datalayout string by a command line option we can bypass this issue. If this does not sounds like a redundant option.

[aprantl]

If the user does not specify target on llc command line, llc is supposed to get the target from LLVM assembly, then use it to get the datalayout string through TargetMachine. However, that means it has to parse the LLVM assembly first, but it cannot. Because to parse the LLVM assembly it needs to know the datalayout string first.

I'm probably missing something obvious here. The case where llc gets invoked without a target on the command line must be working today, doesn't it? Why can't we fall back to that code path?

[yaxunl]

In D41832#989354, @aprantl wrote:

If the user does not specify target on llc command line, llc is supposed to get the target from LLVM assembly, then use it to get the datalayout string through TargetMachine. However, that means it has to parse the LLVM assembly first, but it cannot. Because to parse the LLVM assembly it needs to know the datalayout string first.

I'm probably missing something obvious here. The case where llc gets invoked without a target on the command line must be working today, doesn't it? Why can't we fall back to that code path?

This patch is trying to let llc load an llvm module which does not contain datalayout. In most cases, the parser is able to do that even though there is no datalayout in the module.

However, in some rare cases, the parser needs to know the datalayout to be able to parse the module. Therefore we discussed and concluded that we need to inject datalayout when parsing the module.

Let's consider the situation where llc command line does not contain target.

The old code path just parses the LLVM assembly and gets the target from the assembly. It can do that because it does not need to inject the datalayout.

However, now we need to inject datalayout when parsing, then we cannot since we don't know datalayout unless we parse the module to know the target first.

[yaxunl]

In D41832#989406, @yaxunl wrote:

In D41832#989354, @aprantl wrote:

If the user does not specify target on llc command line, llc is supposed to get the target from LLVM assembly, then use it to get the datalayout string through TargetMachine. However, that means it has to parse the LLVM assembly first, but it cannot. Because to parse the LLVM assembly it needs to know the datalayout string first.

I'm probably missing something obvious here. The case where llc gets invoked without a target on the command line must be working today, doesn't it? Why can't we fall back to that code path?

This patch is trying to let llc load an llvm module which does not contain datalayout. In most cases, the parser is able to do that even though there is no datalayout in the module.

However, in some rare cases, the parser needs to know the datalayout to be able to parse the module. Therefore we discussed and concluded that we need to inject datalayout when parsing the module.

Let's consider the situation where llc command line does not contain target.

The old code path just parses the LLVM assembly and gets the target from the assembly. It can do that because it does not need to inject the datalayout.

However, now we need to inject datalayout when parsing, then we cannot since we don't know datalayout unless we parse the module to know the target first.

My suggestion is

1. Introduce a function parseIRFileWithoutValidation, which does not drop invalid debug info and does not verify module.
2. Add an optional DataLayoutString argument to parseIRFile

parseIRFile will call parseIRFileWithoutValidation, then inject datalayout, then drop invalid debug info and verify the module.

only llc calls parseIRFileWithoutValidation, it will inject datalayout, drop invalid debuginfo and verify module by itself.

All other tools call parseIRFile. They either inject datalayout by command line option, or does not inject datalayout.

[aprantl]

I'm very sorry, I accidentally pasted a wrong review URL into a commit message!

[aprantl]

In D41832#989463, @yaxunl wrote:

In D41832#989406, @yaxunl wrote:

In D41832#989354, @aprantl wrote:

If the user does not specify target on llc command line, llc is supposed to get the target from LLVM assembly, then use it to get the datalayout string through TargetMachine. However, that means it has to parse the LLVM assembly first, but it cannot. Because to parse the LLVM assembly it needs to know the datalayout string first.

I'm probably missing something obvious here. The case where llc gets invoked without a target on the command line must be working today, doesn't it? Why can't we fall back to that code path?

This patch is trying to let llc load an llvm module which does not contain datalayout. In most cases, the parser is able to do that even though there is no datalayout in the module.

However, in some rare cases, the parser needs to know the datalayout to be able to parse the module. Therefore we discussed and concluded that we need to inject datalayout when parsing the module.

Let's consider the situation where llc command line does not contain target.

The old code path just parses the LLVM assembly and gets the target from the assembly. It can do that because it does not need to inject the datalayout.

However, now we need to inject datalayout when parsing, then we cannot since we don't know datalayout unless we parse the module to know the target first.

My suggestion is

1. Introduce a function parseIRFileWithoutValidation, which does not drop invalid debug info and does not verify module.

2. Add an optional DataLayoutString argument to parseIRFile

parseIRFile will call parseIRFileWithoutValidation, then inject datalayout, then drop invalid debug info and verify the module.

only llc calls parseIRFileWithoutValidation, it will inject datalayout, drop invalid debuginfo and verify module by itself.

All other tools call parseIRFile. They either inject datalayout by command line option, or does not inject datalayout.

That sounds good to me, thanks!

[aprantl]

Landed with Jim's changes as r323565.

[yaxunl]

Re-upload the patch.

[yaxunl]

Revised as discussed with Adrian.

It is even simpler than discussed since ParseIRFile etc. already have an argument to disable updating debug info. Therefore no new functions need to be added. Only need to add an argument for overriding data layout.

[aprantl]

Thanks, LGTM!

lib/CodeGen/MIRParser/MIRParser.cpp

240

Perhaps comment what false means?

[yaxunl]

lib/CodeGen/MIRParser/MIRParser.cpp

240

will add /*UpgradeDebugInfo=*/. This is used only by llc, so it is OK to do so since we upgrade debug info explicitly later.

include/llvm/AsmParser/Parser.h

 /// \param Filename The name of the file to parse
 /// \param Error Error result info.
 /// \param Context Context in which to allocate globals info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
 /// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
 ///                         This option should only be set to false by llvm-as
 ///                         for use inside the LLVM testuite!
+/// \param DataLayoutString Override datalayout in the llvm assembly.
 std::unique_ptr<Module>
 parseAssemblyFile(StringRef Filename, SMDiagnostic &Error, LLVMContext &Context,
-                  SlotMapping *Slots = nullptr, bool UpgradeDebugInfo = true);
+                  SlotMapping *Slots = nullptr, bool UpgradeDebugInfo = true,
+                  StringRef DataLayoutString = "");
 
 /// The function is a secondary interface to the LLVM Assembly Parser. It parses
 /// an ASCII string that (presumably) contains LLVM Assembly code. It returns a
 /// Module (intermediate representation) with the corresponding features. Note
 /// that this does not verify that the generated Module is valid, so you should
 /// run the verifier after parsing the file to check that it is okay.
 /// \brief Parse LLVM Assembly from a string
 /// \param AsmString The string containing assembly
 /// \param Error Error result info.
 /// \param Context Context in which to allocate globals info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
 /// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
 ///                         This option should only be set to false by llvm-as
 ///                         for use inside the LLVM testuite!
+/// \param DataLayoutString Override datalayout in the llvm assembly.
 std::unique_ptr<Module> parseAssemblyString(StringRef AsmString,
                                             SMDiagnostic &Error,
                                             LLVMContext &Context,
                                             SlotMapping *Slots = nullptr,
-                                            bool UpgradeDebugInfo = true);
+                                            bool UpgradeDebugInfo = true,
+                                            StringRef DataLayoutString = "");
 
 /// parseAssemblyFile and parseAssemblyString are wrappers around this function.
 /// \brief Parse LLVM Assembly from a MemoryBuffer.
 /// \param F The MemoryBuffer containing assembly
 /// \param Err Error result info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
 /// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
 ///                         This option should only be set to false by llvm-as
 ///                         for use inside the LLVM testuite!
+/// \param DataLayoutString Override datalayout in the llvm assembly.
 std::unique_ptr<Module> parseAssembly(MemoryBufferRef F, SMDiagnostic &Err,
                                       LLVMContext &Context,
                                       SlotMapping *Slots = nullptr,
-                                      bool UpgradeDebugInfo = true);
+                                      bool UpgradeDebugInfo = true,
+                                      StringRef DataLayoutString = "");
 
 /// This function is the low-level interface to the LLVM Assembly Parser.
 /// This is kept as an independent function instead of being inlined into
 /// parseAssembly for the convenience of interactive users that want to add
 /// recently parsed bits to an existing module.
 ///
 /// \param F The MemoryBuffer containing assembly
 /// \param M The module to add data to.
 /// \param Err Error result info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
 /// \return true on error.
 /// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
 ///                         This option should only be set to false by llvm-as
 ///                         for use inside the LLVM testuite!
+/// \param DataLayoutString Override datalayout in the llvm assembly.
 bool parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err,
                        SlotMapping *Slots = nullptr,
-                       bool UpgradeDebugInfo = true);
+                       bool UpgradeDebugInfo = true,
+                       StringRef DataLayoutString = "");
 
 /// Parse a type and a constant value in the given string.
 ///
 /// The constant value can be any LLVM constant, including a constant
 /// expression.
 ///
 /// \param Slots The optional slot mapping that will restore the parsing state
 /// of the module.

include/llvm/IRReader/IRReader.h

 // This file defines functions for reading LLVM IR. They support both
 // Bitcode and Assembly, automatically detecting the input format.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IRREADER_IRREADER_H
 #define LLVM_IRREADER_IRREADER_H
 
+#include "llvm/ADT/StringRef.h"
 #include <memory>
 
 namespace llvm {
 
 class StringRef;
 class MemoryBufferRef;
 class Module;
 class SMDiagnostic;
getLazyIRFileModule(StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
                     bool ShouldLazyLoadMetadata = false);
 
 /// If the given MemoryBuffer holds a bitcode image, return a Module
 /// for it.  Otherwise, attempt to parse it as LLVM Assembly and return
 /// a Module for it.
 /// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
 ///                         This option should only be set to false by llvm-as
 ///                         for use inside the LLVM testuite!
+/// \param DataLayoutString Override datalayout in the llvm assembly.
 std::unique_ptr<Module> parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
                                 LLVMContext &Context,
-                                bool UpgradeDebugInfo = true);
+                                bool UpgradeDebugInfo = true,
+                                StringRef DataLayoutString = "");
 
 /// If the given file holds a bitcode image, return a Module for it.
 /// Otherwise, attempt to parse it as LLVM Assembly and return a Module
 /// for it.
 /// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
 ///                         This option should only be set to false by llvm-as
 ///                         for use inside the LLVM testuite!
+/// \param DataLayoutString Override datalayout in the llvm assembly.
 std::unique_ptr<Module> parseIRFile(StringRef Filename, SMDiagnostic &Err,
                                     LLVMContext &Context,
-                                    bool UpgradeDebugInfo = true);
+                                    bool UpgradeDebugInfo = true,
+                                    StringRef DataLayoutString = "");
 }
 
 #endif

lib/AsmParser/LLParser.h

private:
     // Attribute builder reference information.
     std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
     std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
 
     /// Only the llvm-as tool may set this to false to bypass
     /// UpgradeDebuginfo so it can generate broken bitcode.
     bool UpgradeDebugInfo;
 
+    /// DataLayout string to override that in LLVM assembly.
+    StringRef DataLayoutStr;
+
   public:
     LLParser(StringRef F, SourceMgr &SM, SMDiagnostic &Err, Module *M,
-             SlotMapping *Slots = nullptr, bool UpgradeDebugInfo = true)
+             SlotMapping *Slots = nullptr, bool UpgradeDebugInfo = true,
+             StringRef DataLayoutString = "")
         : Context(M->getContext()), Lex(F, SM, Err, M->getContext()), M(M),
           Slots(Slots), BlockAddressPFS(nullptr),
-          UpgradeDebugInfo(UpgradeDebugInfo) {}
+          UpgradeDebugInfo(UpgradeDebugInfo), DataLayoutStr(DataLayoutString) {
+      if (!DataLayoutStr.empty())
+        M->setDataLayout(DataLayoutStr);
+    }
     bool Run();
 
     bool parseStandaloneConstantValue(Constant *&C, const SlotMapping *Slots);
 
     bool parseTypeAtBeginning(Type *&Ty, unsigned &Read,
                               const SlotMapping *Slots);
 
     LLVMContext &getContext() { return Context; }

lib/AsmParser/LLParser.cpp

       return true;
     M->setTargetTriple(Str);
     return false;
   case lltok::kw_datalayout:
     Lex.Lex();
     if (ParseToken(lltok::equal, "expected '=' after target datalayout") ||
         ParseStringConstant(Str))
       return true;
-    M->setDataLayout(Str);
+    if (DataLayoutStr.empty())
+      M->setDataLayout(Str);
     return false;
   }
 }
 
 /// toplevelentity
 ///   ::= 'source_filename' '=' STRINGCONSTANT
 bool LLParser::ParseSourceFileName() {
   assert(Lex.getKind() == lltok::kw_source_filename);

         }
       }
     }
   }
 
   if (Size && !Size->getType()->isIntegerTy())
     return Error(SizeLoc, "element count must have integer type");
 
-  const DataLayout &DL = M->getDataLayout();
-  unsigned AS = DL.getAllocaAddrSpace();
-  if (AS != AddrSpace) {
-    // TODO: In the future it should be possible to specify addrspace per-alloca.
-    return Error(ASLoc, "address space must match datalayout");
-  }
-
-  AllocaInst *AI = new AllocaInst(Ty, AS, Size, Alignment);
+  AllocaInst *AI = new AllocaInst(Ty, AddrSpace, Size, Alignment);
   AI->setUsedWithInAlloca(IsInAlloca);
   AI->setSwiftError(IsSwiftError);
   Inst = AI;
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
 /// ParseLoad
 ///   ::= 'load' 'volatile'? TypeAndValue (',' 'align' i32)?
 ///   ::= 'load' 'atomic' 'volatile'? TypeAndValue
 ///       'singlethread'? AtomicOrdering (',' 'align' i32)?
 int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Val; LocTy Loc;
   unsigned Alignment = 0;

lib/AsmParser/Parser.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstring>
 #include <system_error>
 using namespace llvm;
 
 bool llvm::parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err,
-                             SlotMapping *Slots, bool UpgradeDebugInfo) {
+                             SlotMapping *Slots, bool UpgradeDebugInfo,
+                             StringRef DataLayoutString) {
   SourceMgr SM;
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F);
   SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
 
-  return LLParser(F.getBuffer(), SM, Err, &M, Slots, UpgradeDebugInfo).Run();
+  return LLParser(F.getBuffer(), SM, Err, &M, Slots, UpgradeDebugInfo,
+                  DataLayoutString)
+      .Run();
 }
 
 std::unique_ptr<Module>
 llvm::parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context,
-                    SlotMapping *Slots, bool UpgradeDebugInfo) {
+                    SlotMapping *Slots, bool UpgradeDebugInfo,
+                    StringRef DataLayoutString) {
   std::unique_ptr<Module> M =
       make_unique<Module>(F.getBufferIdentifier(), Context);
 
-  if (parseAssemblyInto(F, *M, Err, Slots, UpgradeDebugInfo))
+  if (parseAssemblyInto(F, *M, Err, Slots, UpgradeDebugInfo, DataLayoutString))
     return nullptr;
 
   return M;
 }
 
-std::unique_ptr<Module> llvm::parseAssemblyFile(StringRef Filename,
-                                                SMDiagnostic &Err,
-                                                LLVMContext &Context,
-                                                SlotMapping *Slots,
-                                                bool UpgradeDebugInfo) {
+std::unique_ptr<Module>
+llvm::parseAssemblyFile(StringRef Filename, SMDiagnostic &Err,
+                        LLVMContext &Context, SlotMapping *Slots,
+                        bool UpgradeDebugInfo, StringRef DataLayoutString) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   if (std::error_code EC = FileOrErr.getError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
                        "Could not open input file: " + EC.message());
     return nullptr;
   }
 
   return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots,
-                       UpgradeDebugInfo);
+                       UpgradeDebugInfo, DataLayoutString);
 }
 
-std::unique_ptr<Module> llvm::parseAssemblyString(StringRef AsmString,
-                                                  SMDiagnostic &Err,
-                                                  LLVMContext &Context,
-                                                  SlotMapping *Slots,
-                                                  bool UpgradeDebugInfo) {
+std::unique_ptr<Module>
+llvm::parseAssemblyString(StringRef AsmString, SMDiagnostic &Err,
+                          LLVMContext &Context, SlotMapping *Slots,
+                          bool UpgradeDebugInfo, StringRef DataLayoutString) {
   MemoryBufferRef F(AsmString, "<string>");
-  return parseAssembly(F, Err, Context, Slots, UpgradeDebugInfo);
+  return parseAssembly(F, Err, Context, Slots, UpgradeDebugInfo,
+                       DataLayoutString);
 }
 
 Constant *llvm::parseConstantValue(StringRef Asm, SMDiagnostic &Err,
                                    const Module &M, const SlotMapping *Slots) {
   SourceMgr SM;
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
   SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
   Constant *C;

lib/CodeGen/MIRParser/MIRParser.cpp

std::unique_ptr<Module> MIRParserImpl::parseIRModule() {
 
   std::unique_ptr<Module> M;
   // Parse the block scalar manually so that we can return unique pointer
   // without having to go trough YAML traits.
   if (const auto *BSN =
           dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
     SMDiagnostic Error;
     M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
-                      Context, &IRSlots);
+                      Context, &IRSlots, false);
     if (!M) {
       reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange()));
       return nullptr;
     }
     In.nextDocument();
     if (!In.setCurrentDocument())
       NoMIRDocuments = true;
   } else {

lib/IRReader/IRReader.cpp

std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename,
   }
 
   return getLazyIRModule(std::move(FileOrErr.get()), Err, Context,
                          ShouldLazyLoadMetadata);
 }
 
 std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
                                       LLVMContext &Context,
-                                      bool UpgradeDebugInfo) {
+                                      bool UpgradeDebugInfo,
+                                      StringRef DataLayoutString) {
   NamedRegionTimer T(TimeIRParsingName, TimeIRParsingDescription,
                      TimeIRParsingGroupName, TimeIRParsingGroupDescription,
                      TimePassesIsEnabled);
   if (isBitcode((const unsigned char *)Buffer.getBufferStart(),
                 (const unsigned char *)Buffer.getBufferEnd())) {
     Expected<std::unique_ptr<Module>> ModuleOrErr =
         parseBitcodeFile(Buffer, Context);
     if (Error E = ModuleOrErr.takeError()) {
       handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
         Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error,
                            EIB.message());
       });
       return nullptr;
     }
+    if (!DataLayoutString.empty())
+      ModuleOrErr.get()->setDataLayout(DataLayoutString);
     return std::move(ModuleOrErr.get());
   }
 
-  return parseAssembly(Buffer, Err, Context, nullptr, UpgradeDebugInfo);
+  return parseAssembly(Buffer, Err, Context, nullptr, UpgradeDebugInfo,
+                       DataLayoutString);
 }
 
 std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err,
                                           LLVMContext &Context,
-                                          bool UpgradeDebugInfo) {
+                                          bool UpgradeDebugInfo,
+                                          StringRef DataLayoutString) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   if (std::error_code EC = FileOrErr.getError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
                        "Could not open input file: " + EC.message());
     return nullptr;
   }
 
   return parseIR(FileOrErr.get()->getMemBufferRef(), Err, Context,
-                 UpgradeDebugInfo);
+                 UpgradeDebugInfo, DataLayoutString);
 }
 
 //===----------------------------------------------------------------------===//
 // C API.
 //===----------------------------------------------------------------------===//
 
 LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef,
                               LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,

test/Assembler/datalayout-alloca-addrspace-mismatch-0.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
 
 target datalayout = "A1"
 
-; CHECK: :7:41: error: address space must match datalayout
+; CHECK: Allocation instruction pointer not in the stack address space!
+; CHECK-NEXT:  %alloca_scalar_no_align = alloca i32, addrspace(2)
+
 define void @use_alloca() {
   %alloca_scalar_no_align = alloca i32, addrspace(2)
   ret void
 }

test/Assembler/datalayout-alloca-addrspace-mismatch-1.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
 
 target datalayout = "A1"
 
-; CHECK: :7:50: error: address space must match datalayout
+; CHECK: Allocation instruction pointer not in the stack address space!
+; CHECK-NEXT:  %alloca_scalar_no_align = alloca i32, align 4, addrspace(2)
+
 define void @use_alloca() {
   %alloca_scalar_no_align = alloca i32, align 4, addrspace(2)
   ret void
 }

test/Assembler/datalayout-alloca-addrspace-mismatch-2.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
 
 target datalayout = "A1"
 
-; CHECK: :7:50: error: address space must match datalayout
+; CHECK: Allocation instruction pointer not in the stack address space!
+; CHECK-NEXT:  %alloca_scalar_no_align = alloca i32, align 4, addrspace(2), !foo !0
+
 define void @use_alloca() {
   %alloca_scalar_no_align = alloca i32, align 4, addrspace(2), !foo !0
   ret void
 }
 
 !0 = !{}

test/Assembler/drop-debug-info-nonzero-alloca.ll

+; RUN: llvm-as < %s -o %t.bc -data-layout=A5 2>&1 | FileCheck -check-prefixes=COM,AS %s
+; RUN: llvm-dis < %t.bc | FileCheck -check-prefixes=COM,DIS %s
+; RUN: opt < %s -S -data-layout=A5 2>&1 | FileCheck -check-prefixes=COM,AS %s
+; RUN: opt < %t.bc -S | FileCheck -check-prefixes=COM,DIS %s
+
+define void @foo() {
+entry:
+; DIS: target datalayout = "A5"
+; DIS: %tmp = alloca i32, addrspace(5)
+  %tmp = alloca i32, addrspace(5)
+  call void @llvm.dbg.value(
+      metadata i8* undef,
+      metadata !DILocalVariable(scope: !1),
+      metadata !DIExpression())
+; COM-NOT: Allocation instruction pointer not in the stack address space!
+; AS: llvm.dbg.value intrinsic requires a !dbg attachment
+; AS: warning: ignoring invalid debug info in <stdin>
+ret void
+}
+
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.module.flags = !{!0}
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = distinct !DISubprogram(name: "foo")

test/CodeGen/AMDGPU/alloca.ll

+; RUN: llvm-as -data-layout=A5 < %s | llvm-dis | FileCheck %s
+; RUN: llc -mtriple amdgcn-amd-amdhsa-amdgiz < %s
+; RUN: llvm-as -data-layout=A5 < %s | llc -mtriple amdgcn-amd-amdhsa-amdgiz
+; RUN: opt -data-layout=A5 -S < %s
+; RUN: llvm-as -data-layout=A5 < %s | opt -S
+
+; CHECK: %tmp = alloca i32, addrspace(5)
+define amdgpu_kernel void @test() {
+  %tmp = alloca i32, addrspace(5)
+  ret void
+}
+

test/CodeGen/AMDGPU/fence-barrier.ll

-; RUN: llc -mtriple=amdgcn-amd-amdhsa -mcpu=gfx803 -enable-si-insert-waitcnts=1 -verify-machineinstrs < %s | FileCheck --check-prefix=GCN %s
+; RUN: llc -mtriple=amdgcn-amd-amdhsa-amdgiz -mcpu=gfx803 -enable-si-insert-waitcnts=1 -verify-machineinstrs < %s | FileCheck --check-prefix=GCN %s
+; RUN: llvm-as -data-layout=A5 < %s | llc -mtriple=amdgcn-amd-amdhsa-amdgiz -mcpu=gfx803 -enable-si-insert-waitcnts=1 -verify-machineinstrs | FileCheck --check-prefix=GCN %s
 
 declare i8 addrspace(2)* @llvm.amdgcn.dispatch.ptr()
 declare i8 addrspace(2)* @llvm.amdgcn.implicitarg.ptr()
 declare i32 @llvm.amdgcn.workitem.id.x()
 declare i32 @llvm.amdgcn.workgroup.id.x()
 declare void @llvm.amdgcn.s.barrier()
 
 @test_local.temp = internal addrspace(3) global [1 x i32] undef, align 4
 @test_global_local.temp = internal addrspace(3) global [1 x i32] undef, align 4
 
 ; GCN-LABEL: {{^}}test_local
 ; GCN: v_mov_b32_e32 v[[VAL:[0-9]+]], 0x777
 ; GCN: ds_write_b32 v{{[0-9]+}}, v[[VAL]]
 ; GCN: s_waitcnt lgkmcnt(0){{$}}
 ; GCN-NEXT: s_barrier
 ; GCN: flat_store_dword
 define amdgpu_kernel void @test_local(i32 addrspace(1)*) {
-  %2 = alloca i32 addrspace(1)*, align 4
-  store i32 addrspace(1)* %0, i32 addrspace(1)** %2, align 4
+  %2 = alloca i32 addrspace(1)*, align 4, addrspace(5)
+  store i32 addrspace(1)* %0, i32 addrspace(1)* addrspace(5)* %2, align 4
   %3 = call i32 @llvm.amdgcn.workitem.id.x()
   %4 = zext i32 %3 to i64
   %5 = icmp eq i64 %4, 0
   br i1 %5, label %6, label %7
 
 ; <label>:6:                                      ; preds = %1
   store i32 1911, i32 addrspace(3)* getelementptr inbounds ([1 x i32], [1 x i32] addrspace(3)* @test_local.temp, i64 0, i64 0), align 4
   br label %7
 
 ; <label>:7:                                      ; preds = %6, %1
   fence syncscope("workgroup") release
   call void @llvm.amdgcn.s.barrier()
   fence syncscope("workgroup") acquire
   %8 = load i32, i32 addrspace(3)* getelementptr inbounds ([1 x i32], [1 x i32] addrspace(3)* @test_local.temp, i64 0, i64 0), align 4
-  %9 = load i32 addrspace(1)*, i32 addrspace(1)** %2, align 4
+  %9 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(5)* %2, align 4
   %10 = call i8 addrspace(2)* @llvm.amdgcn.dispatch.ptr()
   %11 = call i32 @llvm.amdgcn.workitem.id.x()
   %12 = call i32 @llvm.amdgcn.workgroup.id.x()
   %13 = getelementptr inbounds i8, i8 addrspace(2)* %10, i64 4
   %14 = bitcast i8 addrspace(2)* %13 to i16 addrspace(2)*
   %15 = load i16, i16 addrspace(2)* %14, align 4
   %16 = zext i16 %15 to i32
   %17 = mul i32 %12, %16

 }
 
 ; GCN-LABEL: {{^}}test_global
 ; GCN: v_add_u32_e32 v{{[0-9]+}}, vcc, 0x888, v{{[0-9]+}}
 ; GCN: flat_store_dword
 ; GCN: s_waitcnt vmcnt(0) lgkmcnt(0){{$}}
 ; GCN-NEXT: s_barrier
 define amdgpu_kernel void @test_global(i32 addrspace(1)*) {
-  %2 = alloca i32 addrspace(1)*, align 4
-  %3 = alloca i32, align 4
-  store i32 addrspace(1)* %0, i32 addrspace(1)** %2, align 4
-  store i32 0, i32* %3, align 4
+  %2 = alloca i32 addrspace(1)*, align 4, addrspace(5)
+  %3 = alloca i32, align 4, addrspace(5)
+  store i32 addrspace(1)* %0, i32 addrspace(1)* addrspace(5)* %2, align 4
+  store i32 0, i32 addrspace(5)* %3, align 4
   br label %4
 
 ; <label>:4:                                      ; preds = %58, %1
-  %5 = load i32, i32* %3, align 4
+  %5 = load i32, i32 addrspace(5)* %3, align 4
   %6 = sext i32 %5 to i64
   %7 = call i8 addrspace(2)* @llvm.amdgcn.dispatch.ptr()
   %8 = call i32 @llvm.amdgcn.workitem.id.x()
   %9 = call i32 @llvm.amdgcn.workgroup.id.x()
   %10 = getelementptr inbounds i8, i8 addrspace(2)* %7, i64 4
   %11 = bitcast i8 addrspace(2)* %10 to i16 addrspace(2)*
   %12 = load i16, i16 addrspace(2)* %11, align 4
   %13 = zext i16 %12 to i32
; <label>:22:                                     ; preds = %4
   %31 = add i32 %30, %24
   %32 = call i8 addrspace(2)* @llvm.amdgcn.implicitarg.ptr()
   %33 = zext i32 %31 to i64
   %34 = bitcast i8 addrspace(2)* %32 to i64 addrspace(2)*
   %35 = load i64, i64 addrspace(2)* %34, align 8
   %36 = add i64 %35, %33
   %37 = add i64 %36, 2184
   %38 = trunc i64 %37 to i32
-  %39 = load i32 addrspace(1)*, i32 addrspace(1)** %2, align 4
-  %40 = load i32, i32* %3, align 4
+  %39 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(5)* %2, align 4
+  %40 = load i32, i32 addrspace(5)* %3, align 4
   %41 = sext i32 %40 to i64
   %42 = call i8 addrspace(2)* @llvm.amdgcn.dispatch.ptr()
   %43 = call i32 @llvm.amdgcn.workitem.id.x()
   %44 = call i32 @llvm.amdgcn.workgroup.id.x()
   %45 = getelementptr inbounds i8, i8 addrspace(2)* %42, i64 4
   %46 = bitcast i8 addrspace(2)* %45 to i16 addrspace(2)*
   %47 = load i16, i16 addrspace(2)* %46, align 4
   %48 = zext i16 %47 to i32
   %49 = mul i32 %44, %48
   %50 = add i32 %49, %43
   %51 = call i8 addrspace(2)* @llvm.amdgcn.implicitarg.ptr()
   %52 = zext i32 %50 to i64
   %53 = bitcast i8 addrspace(2)* %51 to i64 addrspace(2)*
   %54 = load i64, i64 addrspace(2)* %53, align 8
   %55 = add i64 %54, %52
   %56 = add i64 %41, %55
   %57 = getelementptr inbounds i32, i32 addrspace(1)* %39, i64 %56
   store i32 %38, i32 addrspace(1)* %57, align 4
   fence syncscope("workgroup") release
   call void @llvm.amdgcn.s.barrier()
   fence syncscope("workgroup") acquire
   br label %58
 
 ; <label>:58:                                     ; preds = %22
-  %59 = load i32, i32* %3, align 4
+  %59 = load i32, i32 addrspace(5)* %3, align 4
   %60 = add nsw i32 %59, 1
-  store i32 %60, i32* %3, align 4
+  store i32 %60, i32 addrspace(5)* %3, align 4
   br label %4
 
 ; <label>:61:                                     ; preds = %4
   ret void
 }
 
 ; GCN-LABEL: {{^}}test_global_local
 ; GCN: v_mov_b32_e32 v[[VAL:[0-9]+]], 0x999
 ; GCN: ds_write_b32 v{{[0-9]+}}, v[[VAL]]
 ; GCN: s_waitcnt vmcnt(0) lgkmcnt(0){{$}}
 ; GCN-NEXT: s_barrier
 ; GCN: flat_store_dword
 define amdgpu_kernel void @test_global_local(i32 addrspace(1)*) {
-  %2 = alloca i32 addrspace(1)*, align 4
-  store i32 addrspace(1)* %0, i32 addrspace(1)** %2, align 4
-  %3 = load i32 addrspace(1)*, i32 addrspace(1)** %2, align 4
+  %2 = alloca i32 addrspace(1)*, align 4, addrspace(5)
+  store i32 addrspace(1)* %0, i32 addrspace(1)* addrspace(5)* %2, align 4
+  %3 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(5)* %2, align 4
   %4 = call i8 addrspace(2)* @llvm.amdgcn.dispatch.ptr()
   %5 = call i32 @llvm.amdgcn.workitem.id.x()
   %6 = call i32 @llvm.amdgcn.workgroup.id.x()
   %7 = getelementptr inbounds i8, i8 addrspace(2)* %4, i64 4
   %8 = bitcast i8 addrspace(2)* %7 to i16 addrspace(2)*
   %9 = load i16, i16 addrspace(2)* %8, align 4
   %10 = zext i16 %9 to i32
   %11 = mul i32 %6, %10
; <label>:22:                                     ; preds = %1
   store i32 2457, i32 addrspace(3)* getelementptr inbounds ([1 x i32], [1 x i32] addrspace(3)* @test_global_local.temp, i64 0, i64 0), align 4
   br label %23
 
 ; <label>:23:                                     ; preds = %22, %1
   fence syncscope("workgroup") release
   call void @llvm.amdgcn.s.barrier()
   fence syncscope("workgroup") acquire
   %24 = load i32, i32 addrspace(3)* getelementptr inbounds ([1 x i32], [1 x i32] addrspace(3)* @test_global_local.temp, i64 0, i64 0), align 4
-  %25 = load i32 addrspace(1)*, i32 addrspace(1)** %2, align 4
+  %25 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(5)* %2, align 4
   %26 = call i8 addrspace(2)* @llvm.amdgcn.dispatch.ptr()
   %27 = call i32 @llvm.amdgcn.workitem.id.x()
   %28 = call i32 @llvm.amdgcn.workgroup.id.x()
   %29 = getelementptr inbounds i8, i8 addrspace(2)* %26, i64 4
   %30 = bitcast i8 addrspace(2)* %29 to i16 addrspace(2)*
   %31 = load i16, i16 addrspace(2)* %30, align 4
   %32 = zext i16 %31 to i32
   %33 = mul i32 %28, %32

test/CodeGen/AMDGPU/invalid-alloca.ll

+; RUN: not llvm-as -data-layout=A5 < %s 2>&1 | FileCheck -check-prefixes=COMMON,AS %s
+; RUN: not llc -mtriple amdgcn-amd-amdhsa-amdgiz < %s 2>&1 | FileCheck -check-prefixes=COMMON,LLC %s
+; RUN: llvm-as < %s | not llc -mtriple amdgcn-amd-amdhsa-amdgiz 2>&1 | FileCheck -check-prefixes=COMMON,LLC %s
+; RUN: not opt -data-layout=A5 -S < %s 2>&1 | FileCheck -check-prefixes=COMMON,LLC %s
+; RUN: llvm-as < %s | not opt -data-layout=A5 2>&1 | FileCheck -check-prefixes=COMMON,LLC %s
+
+; AS: assembly parsed, but does not verify as correct!
+; COMMON: Allocation instruction pointer not in the stack address space!
+; COMMON:  %tmp = alloca i32
+; LLC: error: input module is broken!
+
+define amdgpu_kernel void @test() {
+  %tmp = alloca i32
+  ret void
+}
+

test/CodeGen/AMDGPU/sched-crash-dbg-value.mir

-# RUN: llc -mtriple=amdgcn-amd-amdhsa-opencl -verify-machineinstrs -run-pass=machine-scheduler -o - %s | FileCheck %s
+# RUN: llc -mtriple=amdgcn-amd-amdhsa-amdgizcl -verify-machineinstrs -run-pass=machine-scheduler -o - %s | FileCheck %s
 
 --- |
   %struct.widget.0 = type { float, i32, i32 }
   %struct.baz = type { <4 x float>, <4 x float>, <2 x float>, i32, i32 }
   %struct.snork = type { float, float, float, i32, float, float, float, float, %struct.spam }
   %struct.spam = type { %struct.zot, [16 x i8] }
   %struct.zot = type { float, float, float, float, <4 x float> }
   %struct.wombat = type { <4 x float>, <4 x float>, <4 x float>, <4 x float>, <4 x float>, <4 x float>, <4 x float>, [2 x i16], [2 x i16] }
   %struct.wombat.1 = type { [4 x i32], [4 x i32], [4 x i32], [4 x i32], i32, i32, i32, i32 }
 
   @sched_dbg_value_crash.tmp6 = internal unnamed_addr addrspace(3) global [256 x [16 x i8]] undef, align 16
 
   define amdgpu_kernel void @sched_dbg_value_crash(i8 addrspace(1)* nocapture readonly %arg, i32 addrspace(1)* nocapture readonly %arg1, %struct.widget.0 addrspace(1)* nocapture readonly %arg2, %struct.baz addrspace(1)* nocapture readonly %arg3, %struct.snork addrspace(1)* nocapture %arg4) local_unnamed_addr #2 {
   bb:
     %0 = getelementptr i32, i32 addrspace(1)* %arg1, i64 0, !amdgpu.uniform !3, !amdgpu.noclobber !3
-    %tmp5 = alloca %struct.wombat, align 16
+    %tmp5 = alloca %struct.wombat, align 16, addrspace(5)
     %1 = call noalias nonnull dereferenceable(64) i8 addrspace(2)* @llvm.amdgcn.dispatch.ptr()
     %2 = bitcast i8 addrspace(2)* %1 to i32 addrspace(2)*
     %3 = getelementptr inbounds i32, i32 addrspace(2)* %2, i64 1
     %4 = bitcast i32 addrspace(2)* %3 to <2 x i32> addrspace(2)*, !amdgpu.uniform !3, !amdgpu.noclobber !3
     %5 = load <2 x i32>, <2 x i32> addrspace(2)* %4, align 4, !invariant.load !3
     %6 = extractelement <2 x i32> %5, i32 0
     %7 = extractelement <2 x i32> %5, i32 1
     %8 = lshr i32 %6, 16
bb:
     %tmp15 = getelementptr inbounds %struct.baz, %struct.baz addrspace(1)* %arg3, i64 %tmp12, i32 1
     %tmp16 = load <4 x float>, <4 x float> addrspace(1)* %tmp15, align 16
     %tmp17 = sext i32 %tmp14 to i64
     %tmp18 = load i32, i32 addrspace(1)* %0, align 4
     %tmp19 = zext i32 %tmp18 to i64
     %tmp20 = shl nuw nsw i64 %tmp19, 2
     %tmp21 = getelementptr inbounds i8, i8 addrspace(1)* %arg, i64 %tmp20
     %tmp22 = bitcast i8 addrspace(1)* %tmp21 to %struct.wombat.1 addrspace(1)*
-    %tmp23 = bitcast %struct.wombat* %tmp5 to i8*
-    call void @llvm.lifetime.start.p0i8(i64 144, i8* nonnull %tmp23) #3
-    %tmp24 = getelementptr inbounds %struct.wombat, %struct.wombat* %tmp5, i32 0, i32 6
+    %tmp23 = bitcast %struct.wombat addrspace(5)* %tmp5 to i8 addrspace(5)*
+    call void @llvm.lifetime.start.p5i8(i64 144, i8 addrspace(5)* nonnull %tmp23) #3
+    %tmp24 = getelementptr inbounds %struct.wombat, %struct.wombat addrspace(5)* %tmp5, i32 0, i32 6
     %tmp25 = getelementptr i32, i32 addrspace(1)* %arg1, i64 3, !amdgpu.uniform !3, !amdgpu.noclobber !3
     %tmp26 = load i32, i32 addrspace(1)* %tmp25, align 4
     %tmp27 = zext i32 %tmp26 to i64
     %tmp28 = shl nuw nsw i64 %tmp27, 2
     %tmp29 = getelementptr inbounds i8, i8 addrspace(1)* %arg, i64 %tmp28
     %tmp30 = bitcast i8 addrspace(1)* %tmp29 to <2 x float> addrspace(1)*
     %tmp31 = getelementptr inbounds %struct.wombat.1, %struct.wombat.1 addrspace(1)* %tmp22, i64 %tmp17, i32 2, i64 0
     %18 = bitcast i32 addrspace(1)* %tmp31 to <3 x i32> addrspace(1)*
bb:
     %tmp69 = fsub fast float -0.000000e+00, %tmp67
     %tmp70 = fmul float %tmp67, 0.000000e+00
     %tmp = fmul fast float %tmp67, undef
     %tmp71 = fsub fast float %tmp, %tmp70
     %tmp73 = fadd fast float %tmp, undef
     %tmp74 = insertelement <4 x float> <float undef, float undef, float undef, float 0.000000e+00>, float %tmp69, i32 0
     %tmp75 = insertelement <4 x float> %tmp74, float %tmp71, i32 1
     %tmp76 = insertelement <4 x float> %tmp75, float %tmp73, i32 2
-    store <4 x float> %tmp76, <4 x float>* %tmp24, align 16
+    store <4 x float> %tmp76, <4 x float> addrspace(5)* %tmp24, align 16
     %tmp77 = fsub float undef, %tmp60
     %tmp78 = fsub float undef, %tmp61
     %tmp79 = extractelement <4 x float> %tmp66, i32 2
     %tmp80 = extractelement <4 x float> %tmp59, i32 2
     %tmp81 = fsub float %tmp79, %tmp80
     %tmp82 = fmul fast float %tmp81, undef
     %tmp83 = fmul fast float %tmp78, undef
     %tmp84 = fadd fast float %tmp83, %tmp77
     %tmp85 = fadd fast float %tmp84, undef
     %tmp86 = fmul float %tmp82, %tmp82
     %tmp87 = fdiv float 1.000000e+00, %tmp86
     tail call void @llvm.dbg.value(metadata float %tmp87, metadata !5, metadata !DIExpression(DW_OP_constu, 1, DW_OP_swap, DW_OP_xderef)) #3, !dbg !8
     %tmp88 = fmul float %tmp82, 0.000000e+00
     %tmp89 = fsub fast float %tmp85, %tmp88
     %tmp90 = fdiv float %tmp89, %tmp86
     %tmp91 = fsub float 1.000000e+00, %tmp87
     %tmp92 = fsub float %tmp91, %tmp90
     %tmp93 = fmul float %tmp42, %tmp87
     %tmp94 = call float @llvm.fmuladd.f32(float %tmp92, float %tmp36, float %tmp93)
     %tmp95 = call float @llvm.fmuladd.f32(float %tmp48, float undef, float %tmp94)
     %tmp96 = fsub float extractelement (<2 x float> fadd (<2 x float> fmul (<2 x float> undef, <2 x float> undef), <2 x float> undef), i64 1), %tmp95
-    %tmp97 = getelementptr inbounds %struct.wombat, %struct.wombat* %tmp5, i32 0, i32 8, i32 1
-    call void @func(float %tmp96, i64 0, i16* nonnull %tmp97) #3
+    %tmp97 = getelementptr inbounds %struct.wombat, %struct.wombat addrspace(5)* %tmp5, i32 0, i32 8, i32 1
+    call void @func(float %tmp96, i64 0, i16 addrspace(5)* nonnull %tmp97) #3
     %tmp984 = bitcast [16 x i8] addrspace(3)* %17 to i8 addrspace(3)*
     %tmp99 = getelementptr inbounds %struct.snork, %struct.snork addrspace(1)* %arg4, i64 %tmp12, i32 8, i32 1, i64 0
     call void @llvm.memcpy.p1i8.p3i8.i64(i8 addrspace(1)* %tmp99, i8 addrspace(3)* %tmp984, i64 16, i32 16, i1 false)
-    call void @llvm.lifetime.end.p0i8(i64 144, i8* nonnull %tmp23) #3
+    call void @llvm.lifetime.end.p5i8(i64 144, i8 addrspace(5)* nonnull %tmp23) #3
     ret void
   }
 
-  declare void @func(float, i64, i16*)
-  declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
+  declare void @func(float, i64, i16 addrspace(5)*)
+  declare void @llvm.lifetime.start.p5i8(i64, i8 addrspace(5)* nocapture) #0
   declare float @llvm.fmuladd.f32(float, float, float) #1
-  declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
+  declare void @llvm.lifetime.end.p5i8(i64, i8 addrspace(5)* nocapture) #0
   declare <2 x float> @llvm.fmuladd.v2f32(<2 x float>, <2 x float>, <2 x float>) #1
   declare i32 @llvm.amdgcn.workitem.id.x() #1
   declare void @llvm.dbg.value(metadata, metadata, metadata) #1
   declare i8 addrspace(2)* @llvm.amdgcn.dispatch.ptr() #1
   declare i32 @llvm.amdgcn.workitem.id.y() #1
   declare i32 @llvm.amdgcn.workitem.id.z() #1
-  declare void @llvm.memcpy.p1i8.p0i8.i64(i8 addrspace(1)* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) #0
+  declare void @llvm.memcpy.p1i8.p5i8.i64(i8 addrspace(1)* nocapture writeonly, i8 addrspace(5)* nocapture readonly, i64, i32, i1) #0
   declare void @llvm.memcpy.p1i8.p3i8.i64(i8 addrspace(1)* nocapture writeonly, i8 addrspace(3)* nocapture readonly, i64, i32, i1) #0
 
   attributes #0 = { argmemonly nounwind }
   attributes #1 = { nounwind readnone speculatable }
   attributes #2 = { convergent nounwind "amdgpu-dispatch-ptr" "amdgpu-flat-scratch" "amdgpu-work-item-id-y" "amdgpu-work-item-id-z" "target-cpu"="gfx900" "target-features"="+fp32-denormals" }
   attributes #3 = { nounwind }
 
   !llvm.dbg.cu = !{!0}

tools/llc/llc.cpp

 #include "llvm/CodeGen/CommandFlags.def"
 #include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
 #include "llvm/CodeGen/MIRParser/MIRParser.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include "llvm/IR/AutoUpgrade.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
static int compileModule(char **argv, LLVMContext &Context) {
   // If user just wants to list available options, skip module loading
   if (!SkipModule) {
     if (InputLanguage == "mir" ||
         (InputLanguage == "" && StringRef(InputFilename).endswith(".mir"))) {
       MIR = createMIRParserFromFile(InputFilename, Err, Context);
       if (MIR)
         M = MIR->parseIRModule();
     } else
-      M = parseIRFile(InputFilename, Err, Context);
+      M = parseIRFile(InputFilename, Err, Context, false);
     if (!M) {
       Err.print(argv[0], errs());
       return 1;
     }
 
-    // Verify module immediately to catch problems before doInitialization() is
-    // called on any passes.
-    if (!NoVerify && verifyModule(*M, &errs())) {
-      errs() << argv[0] << ": " << InputFilename
-             << ": error: input module is broken!\n";
-      return 1;
-    }
-
     // If we are supposed to override the target triple, do so now.
     if (!TargetTriple.empty())
       M->setTargetTriple(Triple::normalize(TargetTriple));
     TheTriple = Triple(M->getTargetTriple());
   } else {
     TheTriple = Triple(Triple::normalize(TargetTriple));
   }
 
static int compileModule(char **argv, LLVMContext &Context) {
   // The -disable-simplify-libcalls flag actually disables all builtin optzns.
   if (DisableSimplifyLibCalls)
     TLII.disableAllFunctions();
   PM.add(new TargetLibraryInfoWrapperPass(TLII));
 
   // Add the target data from the target machine, if it exists, or the module.
   M->setDataLayout(Target->createDataLayout());
 
+  // This needs to be done after setting datalayout since it calls verifier
+  // to check debug info whereas verifier relies on correct datalayout.
+  UpgradeDebugInfo(*M);
+
+  // Verify module immediately to catch problems before doInitialization() is
+  // called on any passes.
+  if (!NoVerify && verifyModule(*M, &errs())) {
+    errs() << argv[0] << ": " << InputFilename
+           << ": error: input module is broken!\n";
+    return 1;
+  }
+
   // Override function attributes based on CPUStr, FeaturesStr, and command line
   // flags.
   setFunctionAttributes(CPUStr, FeaturesStr, *M);
 
   if (RelaxAll.getNumOccurrences() > 0 &&
       FileType != TargetMachine::CGFT_ObjectFile)
     errs() << argv[0]
              << ": warning: ignoring -mc-relax-all because filetype != obj";

tools/llvm-as/llvm-as.cpp

static cl::opt<bool>
     DisableVerify("disable-verify", cl::Hidden,
                   cl::desc("Do not run verifier on input LLVM (dangerous!)"));
 
 static cl::opt<bool> PreserveBitcodeUseListOrder(
     "preserve-bc-uselistorder",
     cl::desc("Preserve use-list order when writing LLVM bitcode."),
     cl::init(true), cl::Hidden);
 
+static cl::opt<std::string> ClDataLayout("data-layout",
+                                         cl::desc("data layout string to use"),
+                                         cl::value_desc("layout-string"),
+                                         cl::init(""));
+
 static void WriteOutputFile(const Module *M) {
   // Infer the output filename if needed.
   if (OutputFilename.empty()) {
     if (InputFilename == "-") {
       OutputFilename = "-";
     } else {
       StringRef IFN = InputFilename;
       OutputFilename = (IFN.endswith(".ll") ? IFN.drop_back(3) : IFN).str();
int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
   LLVMContext Context;
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "llvm .ll -> .bc assembler\n");
 
   // Parse the file now...
   SMDiagnostic Err;
-  std::unique_ptr<Module> M =
-      parseAssemblyFile(InputFilename, Err, Context, nullptr, !DisableVerify);
+  std::unique_ptr<Module> M = parseAssemblyFile(
+      InputFilename, Err, Context, nullptr, !DisableVerify, ClDataLayout);
   if (!M.get()) {
     Err.print(argv[0], errs());
     return 1;
   }
 
   if (!DisableVerify) {
     std::string ErrorStr;
     raw_string_ostream OS(ErrorStr);

tools/opt/opt.cpp

if (EC) {
       return 1;
     }
     Context.setDiagnosticsOutputFile(
         llvm::make_unique<yaml::Output>(OptRemarkFile->os()));
   }
 
   // Load the input module...
   std::unique_ptr<Module> M =
-      parseIRFile(InputFilename, Err, Context, !NoVerify);
+      parseIRFile(InputFilename, Err, Context, !NoVerify, ClDataLayout);
 
   if (!M) {
     Err.print(argv[0], errs());
     return 1;
   }
 
   // Strip debug info before running the verifier.
   if (StripDebug)
     StripDebugInfo(*M);
 
+  // If we are supposed to override the target triple or data layout, do so now.
+  if (!TargetTriple.empty())
+    M->setTargetTriple(Triple::normalize(TargetTriple));
+
   // Immediately run the verifier to catch any problems before starting up the
   // pass pipelines.  Otherwise we can crash on broken code during
   // doInitialization().
   if (!NoVerify && verifyModule(*M, &errs())) {
     errs() << argv[0] << ": " << InputFilename
            << ": error: input module is broken!\n";
     return 1;
   }
 
-  // If we are supposed to override the target triple or data layout, do so now.
-  if (!TargetTriple.empty())
-    M->setTargetTriple(Triple::normalize(TargetTriple));
-  if (!ClDataLayout.empty())
-    M->setDataLayout(ClDataLayout);
-
   // Figure out what stream we are supposed to write to...
   std::unique_ptr<ToolOutputFile> Out;
   std::unique_ptr<ToolOutputFile> ThinLinkOut;
   if (NoOutput) {
     if (!OutputFilename.empty())
       errs() << "WARNING: The -o (output filename) option is ignored when\n"
                 "the --disable-output option is used.\n";
   } else {