From f13090c436a7e08bebdd400cd33ede551f6c008a Mon Sep 17 00:00:00 2001 From: Anton Korobeynikov Date: Sun, 6 May 2007 20:13:33 +0000 Subject: [PATCH] Update MSIL BE. This patch fixes most weird glitches outlined in README.txt. Patch by Roman Samoilov! git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36890 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Target/MSIL/MSILWriter.cpp | 536 ++++++++++++++++++++++++++------- lib/Target/MSIL/MSILWriter.h | 30 +- lib/Target/MSIL/README.TXT | 25 -- 3 files changed, 446 insertions(+), 145 deletions(-) diff --git a/lib/Target/MSIL/MSILWriter.cpp b/lib/Target/MSIL/MSILWriter.cpp index 37aed43a738..e986a55a5f8 100644 --- a/lib/Target/MSIL/MSILWriter.cpp +++ b/lib/Target/MSIL/MSILWriter.cpp @@ -1,6 +1,5 @@ -//===-- MSILWriter.cpp - Library for converting LLVM code to MSIL ---------===// // -// The LLVM Compiler Infrastructure +// The LLVM Compiler Infrastructure // // This file was developed by Roman Samoilov and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. @@ -21,6 +20,7 @@ #include "llvm/Analysis/ConstantsScanner.h" #include "llvm/Support/CallSite.h" #include "llvm/Support/InstVisitor.h" +#include "llvm/Support/MathExtras.h" #include "llvm/Transforms/Scalar.h" #include "llvm/ADT/StringExtras.h" @@ -93,7 +93,7 @@ bool MSILWriter::runOnFunction(Function &F) { bool MSILWriter::doInitialization(Module &M) { ModulePtr = &M; - Mang = new Mangler(M); + Mang = new Mangler(M); Out << ".assembly extern mscorlib {}\n"; Out << ".assembly MSIL {}\n\n"; Out << "// External\n"; @@ -102,6 +102,8 @@ bool MSILWriter::doInitialization(Module &M) { printDeclarations(M.getTypeSymbolTable()); Out << "// Definitions\n"; printGlobalVariables(); + Out << "// Startup code\n"; + printModuleStartup(); return false; } @@ -112,6 +114,105 @@ bool MSILWriter::doFinalization(Module &M) { } +void MSILWriter::printModuleStartup() { + Out << + ".method static public int32 $MSIL_Startup() {\n" + "\t.entrypoint\n" + "\t.locals (native int i)\n" + "\t.locals (native int argc)\n" + "\t.locals (native int ptr)\n" + "\t.locals (void* argv)\n" + "\t.locals (string[] args)\n" + "\tcall\tstring[] [mscorlib]System.Environment::GetCommandLineArgs()\n" + "\tdup\n" + "\tstloc\targs\n" + "\tldlen\n" + "\tconv.i4\n" + "\tdup\n" + "\tstloc\targc\n"; + printPtrLoad(TD->getPointerSize()); + Out << + "\tmul\n" + "\tlocalloc\n" + "\tstloc\targv\n" + "\tldc.i4.0\n" + "\tstloc\ti\n" + "L_01:\n" + "\tldloc\ti\n" + "\tldloc\targc\n" + "\tceq\n" + "\tbrtrue\tL_02\n" + "\tldloc\targs\n" + "\tldloc\ti\n" + "\tldelem.ref\n" + "\tcall\tnative int [mscorlib]System.Runtime.InteropServices.Marshal::" + "StringToHGlobalAnsi(string)\n" + "\tstloc\tptr\n" + "\tldloc\targv\n" + "\tldloc\ti\n"; + printPtrLoad(TD->getPointerSize()); + Out << + "\tmul\n" + "\tadd\n" + "\tldloc\tptr\n" + "\tstind.i\n" + "\tldloc\ti\n" + "\tldc.i4.1\n" + "\tadd\n" + "\tstloc\ti\n" + "\tbr\tL_01\n" + "L_02:\n" + "\tcall void $MSIL_Init()\n"; + + // Call user 'main' function. + const Function* F = ModulePtr->getFunction("main"); + if (!F || F->isDeclaration()) { + Out << "\tldc.i4.0\n\tret\n}\n"; + return; + } + bool BadSig = true;; + std::string Args(""); + Function::const_arg_iterator Arg1,Arg2; + + switch (F->arg_size()) { + case 0: + BadSig = false; + break; + case 1: + Arg1 = F->arg_begin(); + if (Arg1->getType()->isInteger()) { + Out << "\tldloc\targc\n"; + Args = getTypeName(Arg1->getType()); + BadSig = false; + } + break; + case 2: + Arg1 = Arg2 = F->arg_begin(); ++Arg2; + if (Arg1->getType()->isInteger() && + Arg2->getType()->getTypeID() == Type::PointerTyID) { + Out << "\tldloc\targc\n\tldloc\targv\n"; + Args = getTypeName(Arg1->getType())+","+getTypeName(Arg2->getType()); + BadSig = false; + } + break; + default: + BadSig = true; + } + + bool RetVoid = (F->getReturnType()->getTypeID() == Type::VoidTyID); + if (BadSig || !F->getReturnType()->isInteger() && !RetVoid) { + Out << "\tldc.i4.0\n"; + } else { + Out << "\tcall\t" << getTypeName(F->getReturnType()) << + getConvModopt(F->getCallingConv()) << "main(" << Args << ")\n"; + if (RetVoid) + Out << "\tldc.i4.0\n"; + else + Out << "\tconv.i4\n"; + } + Out << "\tret\n}\n"; +} + bool MSILWriter::isZeroValue(const Value* V) { if (const Constant *C = dyn_cast(V)) return C->isNullValue(); @@ -177,7 +278,7 @@ std::string MSILWriter::getArrayTypeName(Type::TypeID TyID, const Type* Ty) { if (ElemTy->getTypeID()!=TyID) break; Tmp += ","; } - return getTypeName(ElemTy)+"["+Tmp+"]"; + return getTypeName(ElemTy, false, true)+"["+Tmp+"]"; } @@ -204,7 +305,8 @@ std::string MSILWriter::getPrimitiveTypeName(const Type* Ty, bool isSigned) { } -std::string MSILWriter::getTypeName(const Type* Ty, bool isSigned) { +std::string MSILWriter::getTypeName(const Type* Ty, bool isSigned, + bool isNested) { if (Ty->isPrimitiveType() || Ty->isInteger()) return getPrimitiveTypeName(Ty,isSigned); // FIXME: "OpaqueType" support @@ -212,10 +314,16 @@ std::string MSILWriter::getTypeName(const Type* Ty, bool isSigned) { case Type::PointerTyID: return "void* "; case Type::StructTyID: + if (isNested) + return ModulePtr->getTypeName(Ty); return "valuetype '"+ModulePtr->getTypeName(Ty)+"' "; case Type::ArrayTyID: + if (isNested) + return getArrayTypeName(Ty->getTypeID(),Ty); return "valuetype '"+getArrayTypeName(Ty->getTypeID(),Ty)+"' "; case Type::VectorTyID: + if (isNested) + return getArrayTypeName(Ty->getTypeID(),Ty); return "valuetype '"+getArrayTypeName(Ty->getTypeID(),Ty)+"' "; default: cerr << "Type = " << *Ty << '\n'; @@ -267,12 +375,29 @@ std::string MSILWriter::getTypePostfix(const Type* Ty, bool Expand, } +void MSILWriter::printConvToPtr() { + switch (ModulePtr->getPointerSize()) { + case Module::Pointer32: + printSimpleInstruction("conv.u4"); + break; + case Module::Pointer64: + printSimpleInstruction("conv.u8"); + break; + default: + assert(0 && "Module use not supporting pointer size"); + } +} + + void MSILWriter::printPtrLoad(uint64_t N) { switch (ModulePtr->getPointerSize()) { case Module::Pointer32: printSimpleInstruction("ldc.i4",utostr(N).c_str()); // FIXME: Need overflow test? - assert(N<0xFFFFFFFF && "32-bit pointer overflowed"); + if (!isUInt32(N)) { + cerr << "Value = " << utostr(N) << '\n'; + assert(0 && "32-bit pointer overflowed"); + } break; case Module::Pointer64: printSimpleInstruction("ldc.i8",utostr(N).c_str()); @@ -283,6 +408,12 @@ void MSILWriter::printPtrLoad(uint64_t N) { } +void MSILWriter::printValuePtrLoad(const Value* V) { + printValueLoad(V); + printConvToPtr(); +} + + void MSILWriter::printConstLoad(const Constant* C) { if (const ConstantInt* CInt = dyn_cast(C)) { // Integer constant @@ -291,10 +422,21 @@ void MSILWriter::printConstLoad(const Constant* C) { Out << CInt->getSExtValue(); else Out << CInt->getZExtValue(); - } else if (const ConstantFP* CFp = dyn_cast(C)) { + } else if (const ConstantFP* FP = dyn_cast(C)) { // Float constant - Out << "\tldc." << getTypePostfix(C->getType(),true) << '\t' << - CFp->getValue(); + uint64_t X; + unsigned Size; + if (FP->getType()->getTypeID()==Type::FloatTyID) { + X = FloatToBits(FP->getValue()); + Size = 4; + } else { + X = DoubleToBits(FP->getValue()); + Size = 8; + } + Out << "\tldc.r" << Size << "\t( " << utohexstr(X) << ')'; + } else if (isa(C)) { + // Undefined constant value = NULL. + printPtrLoad(0); } else { cerr << "Constant = " << *C << '\n'; assert(0 && "Invalid constant value"); @@ -304,7 +446,8 @@ void MSILWriter::printConstLoad(const Constant* C) { void MSILWriter::printValueLoad(const Value* V) { - switch (getValueLocation(V)) { + MSILWriter::ValueType Location = getValueLocation(V); + switch (Location) { // Global variable or function address. case GlobalVT: case InternalVT: @@ -313,9 +456,15 @@ void MSILWriter::printValueLoad(const Value* V) { printSimpleInstruction("ldftn", getCallSignature(F->getFunctionType(),NULL,Name).c_str()); } else { + std::string Tmp; const Type* ElemTy = cast(V->getType())->getElementType(); - std::string Tmp = getTypeName(ElemTy)+getValueName(V); - printSimpleInstruction("ldsflda",Tmp.c_str()); + if (Location==GlobalVT && cast(V)->hasDLLImportLinkage()) { + Tmp = "void* "+getValueName(V); + printSimpleInstruction("ldsfld",Tmp.c_str()); + } else { + Tmp = getTypeName(ElemTy)+getValueName(V); + printSimpleInstruction("ldsflda",Tmp.c_str()); + } } break; // Function argument. @@ -454,21 +603,25 @@ void MSILWriter::printSelectInstruction(const Value* Cond, const Value* VTrue, void MSILWriter::printIndirectLoad(const Value* V) { + const Type* Ty = V->getType(); printValueLoad(V); - std::string Tmp = "ldind."+getTypePostfix(V->getType(),false); + if (const PointerType* P = dyn_cast(Ty)) + Ty = P->getElementType(); + std::string Tmp = "ldind."+getTypePostfix(Ty, false); printSimpleInstruction(Tmp.c_str()); } -void MSILWriter::printStoreInstruction(const Instruction* Inst) { - const Value* Val = Inst->getOperand(0); - const Value* Ptr = Inst->getOperand(1); - // Load destination address. +void MSILWriter::printIndirectSave(const Value* Ptr, const Value* Val) { printValueLoad(Ptr); - // Load value. printValueLoad(Val); + printIndirectSave(Val->getType()); +} + + +void MSILWriter::printIndirectSave(const Type* Ty) { // Instruction need signed postfix for any type. - std::string postfix = getTypePostfix(Val->getType(),false); + std::string postfix = getTypePostfix(Ty, false); if (*postfix.begin()=='u') *postfix.begin() = 'i'; postfix = "stind."+postfix; printSimpleInstruction(postfix.c_str()); @@ -512,55 +665,39 @@ void MSILWriter::printCastInstruction(unsigned int Op, const Value* V, void MSILWriter::printGepInstruction(const Value* V, gep_type_iterator I, gep_type_iterator E) { + unsigned Size; // Load address - printValueLoad(V); + printValuePtrLoad(V); // Calculate element offset. - unsigned TySize; - for (++I; I!=E; ++I){ - const Type* Ty = I.getIndexedType(); - const Value* Idx = I.getOperand(); - // Get size of type. - switch (Ty->getTypeID()) { - case Type::IntegerTyID: - case Type::FloatTyID: - case Type::DoubleTyID: - case Type::PointerTyID: - TySize = TD->getTypeSize(Ty); - break; - case Type::StructTyID: - TySize = 0; - break; - case Type::ArrayTyID: - TySize = TD->getTypeSize(cast(Ty)->getElementType()); - break; - case Type::VectorTyID: - TySize = TD->getTypeSize(cast(Ty)->getElementType()); - break; - default: - cerr << "Type = " << *Ty << '\n'; - assert(0 && "Invalid index type in printGepInstruction()"); - } - // Calculate offset to structure field. - if (const StructType* STy = dyn_cast(Ty)) { - TySize = 0; - uint64_t FieldIdx = cast(Idx)->getZExtValue(); - // Offset is the summ of all previous structure fields. - for (uint64_t F = 0; FgetTypeSize(STy->getContainedType(unsigned(F))); - // Add field offset to stack top. - printPtrLoad(TySize); + for (; I!=E; ++I){ + Size = 0; + const Value* IndexValue = I.getOperand(); + if (const StructType* StrucTy = dyn_cast(*I)) { + uint64_t FieldIndex = cast(IndexValue)->getZExtValue(); + // Offset is the sum of all previous structure fields. + for (uint64_t F = 0; FgetTypeSize(StrucTy->getContainedType((unsigned)F)); + printPtrLoad(Size); printSimpleInstruction("add"); continue; + } else if (const SequentialType* SeqTy = dyn_cast(*I)) { + Size = TD->getTypeSize(SeqTy->getElementType()); + } else { + Size = TD->getTypeSize(*I); } // Add offset of current element to stack top. - if (!isZeroValue(Idx)) { - uint64_t TySize = TD->getTypeSize(I.getIndexedType()); - // Constant optimization - if (const ConstantInt* CInt = dyn_cast(Idx)) { - printPtrLoad(CInt->getZExtValue()*TySize); + if (!isZeroValue(IndexValue)) { + // Constant optimization. + if (const ConstantInt* C = dyn_cast(IndexValue)) { + if (C->getValue().isNegative()) { + printPtrLoad(C->getValue().abs().getZExtValue()*Size); + printSimpleInstruction("sub"); + continue; + } else + printPtrLoad(C->getZExtValue()*Size); } else { - printPtrLoad(TySize); - printValueLoad(Idx); + printPtrLoad(Size); + printValuePtrLoad(IndexValue); printSimpleInstruction("mul"); } printSimpleInstruction("add"); @@ -572,7 +709,7 @@ void MSILWriter::printGepInstruction(const Value* V, gep_type_iterator I, std::string MSILWriter::getCallSignature(const FunctionType* Ty, const Instruction* Inst, std::string Name) { - std::string Tmp = ""; + std::string Tmp(""); if (Ty->isVarArg()) Tmp += "vararg "; // Name and return type. Tmp += getTypeName(Ty->getReturnType())+Name+"("; @@ -585,7 +722,7 @@ std::string MSILWriter::getCallSignature(const FunctionType* Ty, // CLR needs to know the exact amount of parameters received by vararg // function, because caller cleans the stack. if (Ty->isVarArg() && Inst) { - // Origin to function arguments in "CallInst" or "InvokeInst" + // Origin to function arguments in "CallInst" or "InvokeInst". unsigned Org = isa(Inst) ? 3 : 1; // Print variable argument types. unsigned NumOperands = Inst->getNumOperands()-Org; @@ -604,7 +741,7 @@ std::string MSILWriter::getCallSignature(const FunctionType* Ty, void MSILWriter::printFunctionCall(const Value* FnVal, const Instruction* Inst) { - // Get function calling convention + // Get function calling convention. std::string Name = ""; if (const CallInst* Call = dyn_cast(Inst)) Name = getConvModopt(Call->getCallingConv()); @@ -614,28 +751,67 @@ void MSILWriter::printFunctionCall(const Value* FnVal, cerr << "Instruction = " << Inst->getName() << '\n'; assert(0 && "Need \"Invoke\" or \"Call\" instruction only"); } - if (const Function* F = dyn_cast(FnVal)) { - // Direct call + // Direct call. Name += getValueName(F); printSimpleInstruction("call", getCallSignature(F->getFunctionType(),Inst,Name).c_str()); } else { - // Indirect function call + // Indirect function call. const PointerType* PTy = cast(FnVal->getType()); const FunctionType* FTy = cast(PTy->getElementType()); - // Load function address + // Load function address. printValueLoad(FnVal); printSimpleInstruction("calli",getCallSignature(FTy,Inst,Name).c_str()); } } +void MSILWriter::printIntrinsicCall(const IntrinsicInst* Inst) { + std::string Name; + switch (Inst->getIntrinsicID()) { + case Intrinsic::vastart: + Name = getValueName(Inst->getOperand(1)); + Name.insert(Name.length()-1,"$valist"); + // Obtain the argument handle. + printSimpleInstruction("ldloca",Name.c_str()); + printSimpleInstruction("arglist"); + printSimpleInstruction("call", + "instance void [mscorlib]System.ArgIterator::.ctor" + "(valuetype [mscorlib]System.RuntimeArgumentHandle)"); + // Save as pointer type "void*" + printValueLoad(Inst->getOperand(1)); + printSimpleInstruction("ldloca",Name.c_str()); + printIndirectSave(PointerType::get(IntegerType::get(8))); + break; + case Intrinsic::vaend: + // Close argument list handle. + printIndirectLoad(Inst->getOperand(1)); + printSimpleInstruction("call","instance void [mscorlib]System.ArgIterator::End()"); + break; + case Intrinsic::vacopy: + // Copy "ArgIterator" valuetype. + printIndirectLoad(Inst->getOperand(1)); + printIndirectLoad(Inst->getOperand(2)); + printSimpleInstruction("cpobj","[mscorlib]System.ArgIterator"); + break; + default: + cerr << "Intrinsic ID = " << Inst->getIntrinsicID() << '\n'; + assert(0 && "Invalid intrinsic function"); + } +} + + void MSILWriter::printCallInstruction(const Instruction* Inst) { - // Load arguments to stack - for (int I = 1, E = Inst->getNumOperands(); I!=E; ++I) - printValueLoad(Inst->getOperand(I)); - printFunctionCall(Inst->getOperand(0),Inst); + if (isa(Inst)) { + // Handle intrinsic function. + printIntrinsicCall(cast(Inst)); + } else { + // Load arguments to stack and call function. + for (int I = 1, E = Inst->getNumOperands(); I!=E; ++I) + printValueLoad(Inst->getOperand(I)); + printFunctionCall(Inst->getOperand(0),Inst); + } } @@ -646,8 +822,9 @@ void MSILWriter::printICmpInstruction(unsigned Predicate, const Value* Left, printBinaryInstruction("ceq",Left,Right); break; case ICmpInst::ICMP_NE: - // Emulate = not (Op1 eq Op2) + // Emulate = not neg (Op1 eq Op2) printBinaryInstruction("ceq",Left,Right); + printSimpleInstruction("neg"); printSimpleInstruction("not"); break; case ICmpInst::ICMP_ULE: @@ -754,6 +931,7 @@ void MSILWriter::printFCmpInstruction(unsigned Predicate, const Value* Left, case FCmpInst::FCMP_UNE: // X != Y printBinaryInstruction("ceq",Left,Right); + printSimpleInstruction("neg"); printSimpleInstruction("not"); break; case FCmpInst::FCMP_ONE: @@ -818,12 +996,36 @@ void MSILWriter::printSwitchInstruction(const SwitchInst* Inst) { } +void MSILWriter::printVAArgInstruction(const VAArgInst* Inst) { + printIndirectLoad(Inst->getOperand(0)); + printSimpleInstruction("call", + "instance typedref [mscorlib]System.ArgIterator::GetNextArg()"); + printSimpleInstruction("refanyval","void*"); + std::string Name = "ldind."+getTypePostfix(PointerType::get(IntegerType::get(8)),false); + printSimpleInstruction(Name.c_str()); +} + + +void MSILWriter::printAllocaInstruction(const AllocaInst* Inst) { + uint64_t Size = TD->getTypeSize(Inst->getAllocatedType()); + // Constant optimization. + if (const ConstantInt* CInt = dyn_cast(Inst->getOperand(0))) { + printPtrLoad(CInt->getZExtValue()*Size); + } else { + printPtrLoad(Size); + printValueLoad(Inst->getOperand(0)); + printSimpleInstruction("mul"); + } + printSimpleInstruction("localloc"); +} + + void MSILWriter::printInstruction(const Instruction* Inst) { const Value *Left = 0, *Right = 0; if (Inst->getNumOperands()>=1) Left = Inst->getOperand(0); if (Inst->getNumOperands()>=2) Right = Inst->getOperand(1); // Print instruction - // FIXME: "ShuffleVector","ExtractElement","InsertElement","VAArg" support. + // FIXME: "ShuffleVector","ExtractElement","InsertElement" support. switch (Inst->getOpcode()) { // Terminator case Instruction::Ret: @@ -878,13 +1080,22 @@ void MSILWriter::printInstruction(const Instruction* Inst) { printBinaryInstruction("xor",Left,Right); break; case Instruction::Shl: - printBinaryInstruction("shl",Left,Right); + printValueLoad(Left); + printValueLoad(Right); + printSimpleInstruction("conv.i4"); + printSimpleInstruction("shl"); break; case Instruction::LShr: - printBinaryInstruction("shr.un",Left,Right); + printValueLoad(Left); + printValueLoad(Right); + printSimpleInstruction("conv.i4"); + printSimpleInstruction("shr.un"); break; case Instruction::AShr: - printBinaryInstruction("shr",Left,Right); + printValueLoad(Left); + printValueLoad(Right); + printSimpleInstruction("conv.i4"); + printSimpleInstruction("shr"); break; case Instruction::Select: printSelectInstruction(Inst->getOperand(0),Inst->getOperand(1),Inst->getOperand(2)); @@ -893,7 +1104,7 @@ void MSILWriter::printInstruction(const Instruction* Inst) { printIndirectLoad(Inst->getOperand(0)); break; case Instruction::Store: - printStoreInstruction(Inst); + printIndirectSave(Inst->getOperand(1), Inst->getOperand(0)); break; case Instruction::Trunc: case Instruction::ZExt: @@ -920,18 +1131,16 @@ void MSILWriter::printInstruction(const Instruction* Inst) { case Instruction::Invoke: printInvokeInstruction(cast(Inst)); break; - case Instruction::Unwind: { - std::string Class = "instance void [mscorlib]System.Exception::.ctor()"; - printSimpleInstruction("newobj",Class.c_str()); + case Instruction::Unwind: + printSimpleInstruction("newobj", + "instance void [mscorlib]System.Exception::.ctor()"); printSimpleInstruction("throw"); break; - } case Instruction::Switch: printSwitchInstruction(cast(Inst)); break; case Instruction::Alloca: - printValueLoad(Inst->getOperand(0)); - printSimpleInstruction("localloc"); + printAllocaInstruction(cast(Inst)); break; case Instruction::Malloc: assert(0 && "LowerAllocationsPass used"); @@ -940,9 +1149,14 @@ void MSILWriter::printInstruction(const Instruction* Inst) { assert(0 && "LowerAllocationsPass used"); break; case Instruction::Unreachable: - printSimpleInstruction("ldnull"); + printSimpleInstruction("ldstr", "\"Unreachable instruction\""); + printSimpleInstruction("newobj", + "instance void [mscorlib]System.Exception::.ctor(string)"); printSimpleInstruction("throw"); break; + case Instruction::VAArg: + printVAArgInstruction(cast(Inst)); + break; default: cerr << "Instruction = " << Inst->getName() << '\n'; assert(0 && "Unsupported instruction"); @@ -988,18 +1202,57 @@ void MSILWriter::printBasicBlock(const BasicBlock* BB) { void MSILWriter::printLocalVariables(const Function& F) { std::string Name; const Type* Ty = NULL; - // Find variables + std::set Printed; + const Value* VaList = NULL; + unsigned StackDepth = 8; + // Find local variables for (const_inst_iterator I = inst_begin(&F), E = inst_end(&F); I!=E; ++I) { + if (I->getOpcode()==Instruction::Call || + I->getOpcode()==Instruction::Invoke) { + // Test stack depth. + if (StackDepthgetNumOperands()) + StackDepth = I->getNumOperands(); + } const AllocaInst* AI = dyn_cast(&*I); if (AI && !isa(AI)) { + // Local variable allocation. Ty = PointerType::get(AI->getAllocatedType()); Name = getValueName(AI); + Out << "\t.locals (" << getTypeName(Ty) << Name << ")\n"; } else if (I->getType()!=Type::VoidTy) { + // Operation result. Ty = I->getType(); Name = getValueName(&*I); - } else continue; - Out << "\t.locals (" << getTypeName(Ty) << Name << ")\n"; + Out << "\t.locals (" << getTypeName(Ty) << Name << ")\n"; + } + // Test on 'va_list' variable + bool isVaList = false; + if (const VAArgInst* VaInst = dyn_cast(&*I)) { + // "va_list" as "va_arg" instruction operand. + isVaList = true; + VaList = VaInst->getOperand(0); + } else if (const IntrinsicInst* Inst = dyn_cast(&*I)) { + // "va_list" as intrinsic function operand. + switch (Inst->getIntrinsicID()) { + case Intrinsic::vastart: + case Intrinsic::vaend: + case Intrinsic::vacopy: + isVaList = true; + VaList = Inst->getOperand(1); + break; + default: + isVaList = false; + } + } + // Print "va_list" variable. + if (isVaList && Printed.insert(VaList).second) { + Name = getValueName(VaList); + Name.insert(Name.length()-1,"$valist"); + Out << "\t.locals (valuetype [mscorlib]System.ArgIterator " + << Name << ")\n"; + } } + printSimpleInstruction(".maxstack",utostr(StackDepth*2).c_str()); } @@ -1153,14 +1406,7 @@ void MSILWriter::printFunction(const Function& F) { Out << ") cil managed\n"; // Body Out << "{\n"; - // FIXME: Convert "string[]" to "argc,argv" - if (F.getName()=="main") { - printSimpleInstruction(".entrypoint"); - printLocalVariables(F); - printStaticInitializerList(); - } else { - printLocalVariables(F); - } + printLocalVariables(F); printFunctionBody(F); Out << "}\n"; } @@ -1169,16 +1415,11 @@ void MSILWriter::printFunction(const Function& F) { void MSILWriter::printDeclarations(const TypeSymbolTable& ST) { std::string Name; std::set Printed; - //cerr << "UsedTypes = " << UsedTypes << '\n'; for (std::set::const_iterator UI = UsedTypes->begin(), UE = UsedTypes->end(); UI!=UE; ++UI) { const Type* Ty = *UI; - if (isa(Ty)) - Name = getArrayTypeName(Ty->getTypeID(),Ty); - else if (isa(Ty)) - Name = getArrayTypeName(Ty->getTypeID(),Ty); - else if (isa(Ty)) - Name = ModulePtr->getTypeName(Ty); + if (isa(Ty) || isa(Ty) || isa(Ty)) + Name = getTypeName(Ty, false, true); // Type with no need to declare. else continue; // Print not duplicated type @@ -1228,8 +1469,11 @@ void MSILWriter::printStaticConstant(const Constant* C, uint64_t& Offset) { case Type::FloatTyID: case Type::DoubleTyID: { TySize = TD->getTypeSize(Ty); - const ConstantFP* CFp = cast(C); - Out << getPrimitiveTypeName(Ty,true) << "(" << CFp->getValue() << ")"; + const ConstantFP* FP = cast(C); + if (Ty->getTypeID() == Type::FloatTyID) + Out << "int32 (" << FloatToBits(FP->getValue()) << ')'; + else + Out << "int64 (" << DoubleToBits(FP->getValue()) << ')'; break; } case Type::ArrayTyID: @@ -1271,7 +1515,7 @@ void MSILWriter::printStaticInitializer(const Constant* C, case Type::IntegerTyID: case Type::FloatTyID: case Type::DoubleTyID: - Out << getPrimitiveTypeName(C->getType(),true); + Out << getPrimitiveTypeName(C->getType(), false); break; case Type::ArrayTyID: case Type::VectorTyID: @@ -1309,33 +1553,91 @@ void MSILWriter::printGlobalVariables() { Module::global_iterator I,E; for (I = ModulePtr->global_begin(), E = ModulePtr->global_end(); I!=E; ++I) { // Variable definition - if (I->isDeclaration()) continue; - Out << ".field static " << (I->hasExternalLinkage() ? "public " : - "private "); - printVariableDefinition(&*I); + Out << ".field static " << (I->isDeclaration() ? "public " : + "private "); + if (I->isDeclaration()) { + Out << getTypeName(I->getType()) << getValueName(&*I) << "\n\n"; + } else + printVariableDefinition(&*I); } } +const char* MSILWriter::getLibraryName(const Function* F) { + return getLibraryForSymbol(F->getName().c_str(), true, F->getCallingConv()); +} + + +const char* MSILWriter::getLibraryName(const GlobalVariable* GV) { + return getLibraryForSymbol(Mang->getValueName(GV).c_str(), false, 0); +} + + +const char* MSILWriter::getLibraryForSymbol(const char* Name, bool isFunction, + unsigned CallingConv) { + // TODO: Read *.def file with function and libraries definitions. + return "MSVCRT.DLL"; +} + + void MSILWriter::printExternals() { Module::const_iterator I,E; + // Functions. for (I=ModulePtr->begin(),E=ModulePtr->end(); I!=E; ++I) { // Skip intrisics if (I->getIntrinsicID()) continue; - // FIXME: Treat as standard library function if (I->isDeclaration()) { - const Function* F = &*I; - const FunctionType* FTy = F->getFunctionType(); + const Function* F = I; std::string Name = getConvModopt(F->getCallingConv())+getValueName(F); - std::string Sig = getCallSignature(FTy,NULL,Name); - Out << ".method static hidebysig pinvokeimpl(\"msvcrt.dll\" cdecl)\n\t" - << Sig << " preservesig {}\n\n"; + std::string Sig = + getCallSignature(cast(F->getFunctionType()), NULL, Name); + Out << ".method static hidebysig pinvokeimpl(\"" + << getLibraryName(F) << "\")\n\t" << Sig << " preservesig {}\n\n"; } } + // External variables and static initialization. + Out << + ".method public hidebysig static pinvokeimpl(\"KERNEL32.DLL\" ansi winapi)" + " native int LoadLibrary(string) preservesig {}\n" + ".method public hidebysig static pinvokeimpl(\"KERNEL32.DLL\" ansi winapi)" + " native int GetProcAddress(native int, string) preservesig {}\n"; + Out << + ".method private static void* $MSIL_Import(string lib,string sym)\n" + " managed cil\n{\n" + "\tldarg\tlib\n" + "\tcall\tnative int LoadLibrary(string)\n" + "\tldarg\tsym\n" + "\tcall\tnative int GetProcAddress(native int,string)\n" + "\tdup\n" + "\tbrtrue\tL_01\n" + "\tldstr\t\"Can no import variable\"\n" + "\tnewobj\tinstance void [mscorlib]System.Exception::.ctor(string)\n" + "\tthrow\n" + "L_01:\n" + "\tret\n" + "}\n\n" + ".method static private void $MSIL_Init() managed cil\n{\n"; + printStaticInitializerList(); + // Foreach global variable. + for (Module::global_iterator I = ModulePtr->global_begin(), + E = ModulePtr->global_end(); I!=E; ++I) { + if (!I->isDeclaration() || !I->hasDLLImportLinkage()) continue; + // Use "LoadLibrary"/"GetProcAddress" to recive variable address. + std::string Label = "not_null$_"+utostr(getUniqID()); + std::string Tmp = getTypeName(I->getType())+getValueName(&*I); + printSimpleInstruction("ldsflda",Tmp.c_str()); + Out << "\tldstr\t\"" << getLibraryName(&*I) << "\"\n"; + Out << "\tldstr\t\"" << Mang->getValueName(&*I) << "\"\n"; + printSimpleInstruction("call","void* $MSIL_Import(string,string)"); + printIndirectSave(I->getType()); + } + printSimpleInstruction("ret"); + Out << "}\n\n"; } + //===----------------------------------------------------------------------===// -// External Interface declaration +// External Interface declaration //===----------------------------------------------------------------------===// bool MSILTarget::addPassesToEmitWholeFile(PassManager &PM, std::ostream &o, diff --git a/lib/Target/MSIL/MSILWriter.h b/lib/Target/MSIL/MSILWriter.h index 3db825fedb7..c2cd0ab88d9 100644 --- a/lib/Target/MSIL/MSILWriter.h +++ b/lib/Target/MSIL/MSILWriter.h @@ -16,6 +16,7 @@ #include "llvm/Constants.h" #include "llvm/Module.h" #include "llvm/Instructions.h" +#include "llvm/IntrinsicInst.h" #include "llvm/Pass.h" #include "llvm/PassManager.h" #include "llvm/Analysis/FindUsedTypes.h" @@ -67,7 +68,7 @@ namespace { : constant(_constant), offset(_offset) {} }; - uint64_t UniqID; + uint64_t UniqID; uint64_t getUniqID() { return ++UniqID; @@ -119,6 +120,8 @@ namespace { virtual bool doFinalization(Module &M); + void printModuleStartup(); + bool isZeroValue(const Value* V); std::string getValueName(const Value* V); @@ -137,15 +140,20 @@ namespace { std::string getPointerTypeName(const Type* Ty); - std::string getTypeName(const Type* Ty, bool isSigned = false); + std::string getTypeName(const Type* Ty, bool isSigned = false, + bool isNested = false); ValueType getValueLocation(const Value* V); std::string getTypePostfix(const Type* Ty, bool Expand, bool isSigned = false); + void printConvToPtr(); + void printPtrLoad(uint64_t N); + void printValuePtrLoad(const Value* V); + void printConstLoad(const Constant* C); void printValueLoad(const Value* V); @@ -170,7 +178,9 @@ namespace { void printIndirectLoad(const Value* V); - void printStoreInstruction(const Instruction* Inst); + void printIndirectSave(const Value* Ptr, const Value* Val); + + void printIndirectSave(const Type* Ty); void printCastInstruction(unsigned int Op, const Value* V, const Type* Ty); @@ -184,6 +194,8 @@ namespace { void printFunctionCall(const Value* FnVal, const Instruction* Inst); + void printIntrinsicCall(const IntrinsicInst* Inst); + void printCallInstruction(const Instruction* Inst); void printICmpInstruction(unsigned Predicate, const Value* Left, @@ -196,6 +208,10 @@ namespace { void printSwitchInstruction(const SwitchInst* Inst); + void printVAArgInstruction(const VAArgInst* Inst); + + void printAllocaInstruction(const AllocaInst* Inst); + void printInstruction(const Instruction* Inst); void printLoop(const Loop* L); @@ -224,8 +240,16 @@ namespace { void printGlobalVariables(); + const char* getLibraryName(const Function* F); + + const char* getLibraryName(const GlobalVariable* GV); + + const char* getLibraryForSymbol(const char* Name, bool isFunction, + unsigned CallingConv); + void printExternals(); }; } #endif + diff --git a/lib/Target/MSIL/README.TXT b/lib/Target/MSIL/README.TXT index 34c7f1d8386..2b9a569cfdd 100644 --- a/lib/Target/MSIL/README.TXT +++ b/lib/Target/MSIL/README.TXT @@ -12,24 +12,6 @@ Add "OpaqueType" type. //===---------------------------------------------------------------------===// -Variable argument functions support, "VAArg" instruction and some intrinsics. -CLI instruction "arglist" can get argument list descriptor for current function -that can be passed to other functions. - - va_arg = Function "System.ArgIterator::GetNextArg()" - va_list = Class "System.ArgIterator" - va_start = Instruction "arglist" - va_end = Do nothing - -//===---------------------------------------------------------------------===// - -If possible get used types inside of "MSILWriter" class, do not pass trougth -"MSILModule" class. - - getAnalysis().getTypes() - -//===---------------------------------------------------------------------===// - "switch" instruction emulation with CLI "switch" instruction. //===---------------------------------------------------------------------===// @@ -40,12 +22,5 @@ dynamic library where function located. .method static hidebysig pinvokeimpl("msvcrt.dll" cdecl) void free(void*) preservesig {} -//===---------------------------------------------------------------------===// - -DLLImport'ed variables support with the help of win32 envoronment. - - "LoadLibrary" - to load dynamic library into address space. - "GetProcAddress" - to recive variable address by name. - -- 2.34.1