Subzero: Partial implementation of global initializers.
This is still missing a couple things:
1. It only supports flat arrays and zeroinitializers. Arrays of structs are not yet supported.
2. Initializers can't yet contain relocatables, e.g. the address of another global.Mod
Some changes are made to work around an llvm-mc assembler bug. When assembling using intel syntax, llvm-mc doesn't correctly parse symbolic constants or add relocation entries in some circumstances. Call instructions work, and use in a memory operand works, e.g. mov eax, [ArrayBase+4*ecx]. To work around this, we adjust legalize() to not allow ConstantRelocatable by default, except for memory operands and when called from lowerCall(), so the relocatable ends up being the source operand of a mov instruction. Then, the mov emit routine actually emits an lea instruction for such moves.
A few lit tests needed to be adjusted to make szdiff work properly with respect to global initializers.
In the new cross test, the driver calls test code that returns a pointer to an array with a global initializer, and the driver compares the arrays returned by llc and Subzero.
BUG= none
R=jvoung@chromium.org
Review URL: https://codereview.chromium.org/358013003
diff --git a/src/llvm2ice.cpp b/src/llvm2ice.cpp
index 01d4f9b..6d26cff53 100644
--- a/src/llvm2ice.cpp
+++ b/src/llvm2ice.cpp
@@ -13,11 +13,16 @@
//
//===----------------------------------------------------------------------===//
+#include "IceCfg.h"
#include "IceConverter.h"
#include "IceDefs.h"
+#include "IceTargetLowering.h"
#include "IceTypes.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
#include "llvm/IRReader/IRReader.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_os_ostream.h"
@@ -94,9 +99,10 @@
clEnumValEnd),
cl::init(LLVMFormat));
-static cl::opt<bool> BuildOnRead(
- "build-on-read", cl::desc("Build ICE instructions when reading bitcode"),
- cl::init(false));
+static cl::opt<bool>
+BuildOnRead("build-on-read",
+ cl::desc("Build ICE instructions when reading bitcode"),
+ cl::init(false));
int main(int argc, char **argv) {
@@ -129,8 +135,8 @@
// Parse the input LLVM IR file into a module.
SMDiagnostic Err;
Ice::Timer T;
- Module *Mod = NaClParseIRFile(IRFilename, InputFileFormat, Err,
- getGlobalContext());
+ Module *Mod =
+ NaClParseIRFile(IRFilename, InputFileFormat, Err, getGlobalContext());
if (SubzeroTimingEnabled) {
std::cerr << "[Subzero timing] IR Parsing: " << T.getElapsedSec()
@@ -142,6 +148,47 @@
return 1;
}
+ // TODO(stichnot): Move this into IceConverter.cpp.
+ OwningPtr<Ice::TargetGlobalInitLowering> GlobalLowering(
+ Ice::TargetGlobalInitLowering::createLowering(TargetArch, &Ctx));
+ for (Module::const_global_iterator I = Mod->global_begin(),
+ E = Mod->global_end();
+ I != E; ++I) {
+ if (!I->hasInitializer())
+ continue;
+ const Constant *Initializer = I->getInitializer();
+ Ice::IceString Name = I->getName();
+ unsigned Align = I->getAlignment();
+ uint64_t NumElements = 0;
+ const char *Data = NULL;
+ bool IsInternal = I->hasInternalLinkage();
+ bool IsConst = I->isConstant();
+ bool IsZeroInitializer = false;
+
+ if (const ConstantDataArray *CDA =
+ dyn_cast<ConstantDataArray>(Initializer)) {
+ NumElements = CDA->getNumElements();
+ assert(isa<IntegerType>(CDA->getElementType()) &&
+ cast<IntegerType>(CDA->getElementType())->getBitWidth() == 8);
+ Data = CDA->getRawDataValues().data();
+ } else if (isa<ConstantAggregateZero>(Initializer)) {
+ if (const ArrayType *AT = dyn_cast<ArrayType>(Initializer->getType())) {
+ assert(isa<IntegerType>(AT->getElementType()) &&
+ cast<IntegerType>(AT->getElementType())->getBitWidth() == 8);
+ NumElements = AT->getNumElements();
+ IsZeroInitializer = true;
+ } else {
+ llvm_unreachable("Unhandled constant aggregate zero type");
+ }
+ } else {
+ llvm_unreachable("Unhandled global initializer");
+ }
+
+ GlobalLowering->lower(Name, Align, IsInternal, IsConst, IsZeroInitializer,
+ NumElements, Data, DisableTranslation);
+ }
+ GlobalLowering.reset();
+
Ice::Converter Converter(&Ctx, DisableInternal, SubzeroTimingEnabled,
DisableTranslation);
return Converter.convertToIce(Mod);
