From eb6850bae68510c3061bd423329df1d3cd380f17 Mon Sep 17 00:00:00 2001 From: binaryfz Date: Fri, 28 May 2021 22:00:43 +0800 Subject: [PATCH] [me]: create reg directly.[mapleall] opt sub+abs.[mapleall] add simplify --- .../include/cg/aarch64/aarch64_cgfunc.h | 1 + .../include/cg/aarch64/aarch64_color_ra.h | 1 + .../include/cg/aarch64/aarch64_md.def | 21 +- .../include/cg/aarch64/aarch64_ra_opt.h | 22 +- src/mapleall/maple_be/include/cg/ra_opt.h | 1 - src/mapleall/maple_be/src/be/lower.cpp | 3 - .../src/cg/aarch64/aarch64_cgfunc.cpp | 29 +- .../src/cg/aarch64/aarch64_color_ra.cpp | 7 +- .../maple_be/src/cg/aarch64/aarch64_lsra.cpp | 1 + .../src/cg/aarch64/aarch64_proepilog.cpp | 2 +- .../src/cg/aarch64/aarch64_ra_opt.cpp | 117 +++-- .../maple_be/src/cg/cg_phasemanager.cpp | 9 +- src/mapleall/maple_driver/defs/phases.def | 1 + .../maple_ipa/include/module_phases.def | 1 + .../maple_ipa/src/module_phase_manager.cpp | 1 + src/mapleall/maple_me/src/me_bb_layout.cpp | 18 +- src/mapleall/maple_me/src/me_loop_canon.cpp | 9 +- src/mapleall/maple_me/src/ssa_pre.cpp | 19 +- src/mapleall/mpl2mpl/BUILD.gn | 1 + src/mapleall/mpl2mpl/include/simplify.h | 61 +++ src/mapleall/mpl2mpl/src/simplify.cpp | 154 +++++++ .../ast_input/include/ast_builtin_func.def | 1 - src/mplfe/ast_input/include/ast_decl.h | 1 + src/mplfe/ast_input/include/ast_expr.h | 38 +- src/mplfe/ast_input/include/ast_op.h | 2 + src/mplfe/ast_input/include/ast_parser.h | 2 + src/mplfe/ast_input/include/ast_stmt.h | 13 +- src/mplfe/ast_input/lib/ast_interface.cpp | 2 +- src/mplfe/ast_input/lib/ast_interface.h | 2 +- src/mplfe/ast_input/src/ast_decl.cpp | 4 + src/mplfe/ast_input/src/ast_expr.cpp | 415 +++++------------- src/mplfe/ast_input/src/ast_function.cpp | 4 +- src/mplfe/ast_input/src/ast_parser.cpp | 93 ++-- .../src/ast_parser_builting_func.cpp | 8 +- src/mplfe/ast_input/src/ast_stmt.cpp | 23 + src/mplfe/common/include/feir_stmt.h | 18 + src/mplfe/common/src/feir_builder.cpp | 9 +- src/mplfe/common/src/feir_stmt.cpp | 65 +-- 38 files changed, 660 insertions(+), 519 deletions(-) create mode 100644 src/mapleall/mpl2mpl/include/simplify.h create mode 100644 src/mapleall/mpl2mpl/src/simplify.cpp diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_cgfunc.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cgfunc.h index 68adf83ef3..a85256630e 100644 --- a/src/mapleall/maple_be/include/cg/aarch64/aarch64_cgfunc.h +++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_cgfunc.h @@ -175,6 +175,7 @@ class AArch64CGFunc : public CGFunc { Operand *SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1) override; void SelectDiv(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override; Operand *SelectDiv(BinaryNode &node, Operand &opnd0, Operand &opnd1) override; + Operand *SelectAbsSub(Insn &lastInsn, const UnaryNode &node, Operand &newOpnd0); Operand *SelectAbs(UnaryNode &node, Operand &opnd0) override; Operand *SelectBnot(UnaryNode &node, Operand &opnd0) override; Operand *SelectExtractbits(ExtractbitsNode &node, Operand &opnd0) override; diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_color_ra.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_color_ra.h index 7be60e8e69..a69dd953a9 100644 --- a/src/mapleall/maple_be/include/cg/aarch64/aarch64_color_ra.h +++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_color_ra.h @@ -30,6 +30,7 @@ namespace maplebe { #undef REUSE_SPILLMEM #undef COLOR_SPLIT #undef MOVE_COALESCE + /* for robust test */ #undef CONSISTENT_MEMOPND #undef RANDOM_PRIORITY diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_md.def b/src/mapleall/maple_be/include/cg/aarch64/aarch64_md.def index bdaecc9350..4bc556f170 100644 --- a/src/mapleall/maple_be/include/cg/aarch64/aarch64_md.def +++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_md.def @@ -77,22 +77,39 @@ DEFINE_MOP(MOP_dadd, {mopdReg64FD,mopdReg64FS,mopdReg64FS},0,kLtFpalu,"fadd","0, /* MOP_sadd */ DEFINE_MOP(MOP_sadd, {mopdReg32FD,mopdReg32FS,mopdReg32FS},0,kLtFpalu,"fadd","0,1,2",1) -/* MOP_xsubrrr AARCH64 Arithmetic: sub */ +/* AARCH64 Arithmetic: sub */ +/* MOP_xsubrrr */ DEFINE_MOP(MOP_xsubrrr, {mopdReg64ID,mopdReg64IS,mopdReg64IS},0,kLtAlu,"sub","0,1,2",1) +/* MOP_xsubsrrr */ +DEFINE_MOP(MOP_xsubsrrr, {mopdRegCCD, mopdReg64ID,mopdReg64IS,mopdReg64IS},0,kLtAlu,"subs","1,2,3",1) /* MOP_xsubrrrs */ DEFINE_MOP(MOP_xsubrrrs, {mopdReg64ID,mopdReg64IS,mopdReg64IS,mopdBitShift64},0,kLtAluShift,"sub","0,1,2,3",1) +/* MOP_xsubsrrrs */ +DEFINE_MOP(MOP_xsubsrrrs, {mopdRegCCD, mopdReg64ID,mopdReg64IS,mopdReg64IS,mopdBitShift64},0,kLtAluShift,"subs","1,2,3,4",1) /* MOP_xsubrri24 */ DEFINE_MOP(MOP_xsubrri24, {mopdReg64ID,mopdReg64IS,mopdImm12,mopdLSL12},0,kLtAluShift,"sub","0,1,2,3",1) +/* MOP_xsubsrri24 */ +DEFINE_MOP(MOP_xsubsrri24, {mopdRegCCD, mopdReg64ID,mopdReg64IS,mopdImm12,mopdLSL12},0,kLtAluShift,"subs","1,2,3,4",1) /* MOP_xsubrri12 */ DEFINE_MOP(MOP_xsubrri12, {mopdReg64ID,mopdReg64IS,mopdImm12},0,kLtAlu,"sub","0,1,2",1) +/* MOP_xsubsrri12 */ +DEFINE_MOP(MOP_xsubsrri12, {mopdRegCCD, mopdReg64ID,mopdReg64IS,mopdImm12},0,kLtAlu,"subs","1,2,3",1) /* MOP_wsubrrr */ DEFINE_MOP(MOP_wsubrrr, {mopdReg32ID,mopdReg32IS,mopdReg32IS},0,kLtAlu,"sub","0,1,2",1) +/* MOP_wsubsrrr */ +DEFINE_MOP(MOP_wsubsrrr, {mopdRegCCD,mopdReg32ID,mopdReg32IS,mopdReg32IS},0,kLtAlu,"subs","1,2,3",1) /* MOP_wsubrrrs */ DEFINE_MOP(MOP_wsubrrrs, {mopdReg32ID,mopdReg32IS,mopdReg32IS,mopdBitShift32},0,kLtAluShift,"sub","0,1,2,3",1) +/* MOP_wsubsrrrs */ +DEFINE_MOP(MOP_wsubsrrrs, {mopdRegCCD,mopdReg32ID,mopdReg32IS,mopdReg32IS,mopdBitShift32},0,kLtAluShift,"subs","1,2,3,4",1) /* MOP_wsubrri24 */ DEFINE_MOP(MOP_wsubrri24, {mopdReg32ID,mopdReg32IS,mopdImm12,mopdLSL12},0,kLtAluShift,"sub","0,1,2,3",1) +/* MOP_wsubsrri24 */ +DEFINE_MOP(MOP_wsubsrri24, {mopdRegCCD,mopdReg32ID,mopdReg32IS,mopdImm12,mopdLSL12},0,kLtAluShift,"subs","1,2,3,4",1) /* MOP_wsubrri12 */ DEFINE_MOP(MOP_wsubrri12, {mopdReg32ID,mopdReg32IS,mopdImm12},0,kLtAlu,"sub","0,1,2",1) +/* MOP_wsubsrri12 */ +DEFINE_MOP(MOP_wsubsrri12, {mopdRegCCD,mopdReg32ID,mopdReg32IS,mopdImm12},0,kLtAlu,"subs","1,2,3",1) /* MOP_dsub */ DEFINE_MOP(MOP_dsub, {mopdReg64FD,mopdReg64FS,mopdReg64FS},0,kLtFpalu,"fsub","0,1,2",1) /* MOP_ssub */ @@ -338,6 +355,8 @@ DEFINE_MOP(MOP_xdfmovri, {mopdReg64FD,mopdImm8},ISMOVE,kLtFconst,"fmov","0,1",1) /* MOP_xcsneg -- Conditional Select Negation */ DEFINE_MOP(MOP_wcsnegrrrc, {mopdReg32ID,mopdReg32IS,mopdReg32IS,mopdCond},ISCONDDEF,kLtAlu,"csneg","0,1,2,3",1) DEFINE_MOP(MOP_xcsnegrrrc, {mopdReg64ID,mopdReg64IS,mopdReg64IS,mopdCond},ISCONDDEF,kLtAlu,"csneg","0,1,2,3",1) +DEFINE_MOP(MOP_wcnegrrrc, {mopdReg32ID,mopdReg32IS,mopdCond},ISCONDDEF,kLtAlu,"cneg","0,1,2",1) +DEFINE_MOP(MOP_xcnegrrrc, {mopdReg64ID,mopdReg64IS,mopdCond},ISCONDDEF,kLtAlu,"cneg","0,1,2",1) /* MOP_sabsrr */ DEFINE_MOP(MOP_sabsrr, {mopdReg32FD,mopdReg32FS},0,kLtFpalu,"fabs","0,1",1) diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_ra_opt.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ra_opt.h index 4c69d173b2..fcfbe1c5ec 100644 --- a/src/mapleall/maple_be/include/cg/aarch64/aarch64_ra_opt.h +++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_ra_opt.h @@ -23,7 +23,6 @@ #include "aarch64_operand.h" namespace maplebe { - class X0OptInfo { public: X0OptInfo() : movSrc(nullptr), replaceReg(0), renameInsn(nullptr), renameOpnd(nullptr), renameReg(0) {} @@ -82,19 +81,19 @@ class X0OptInfo { class RaX0Opt { public: - RaX0Opt(CGFunc* func) : cgFunc(func) {} + explicit RaX0Opt(CGFunc* func) : cgFunc(func) {} - bool PropagateX0CanReplace(Operand *opnd, regno_t replaceReg); - bool PropagateRenameReg(Insn *insn, X0OptInfo &optVal); - bool PropagateX0DetectX0(Insn *insn, X0OptInfo &optVal); - bool PropagateX0DetectRedefine(const AArch64MD *md, Insn *ninsn, const X0OptInfo &optVal, uint32 index); + bool PropagateX0CanReplace(Operand *opnd, regno_t replaceReg) const; + bool PropagateRenameReg(Insn *insn, const X0OptInfo &optVal); + bool PropagateX0DetectX0(const Insn *insn, X0OptInfo &optVal); + bool PropagateX0DetectRedefine(const AArch64MD *md, const Insn *ninsn, const X0OptInfo &optVal, uint32 index); bool PropagateX0Optimize(const BB *bb, const Insn *insn, X0OptInfo &optVal); - bool PropagateX0ForCurrBb(BB *bb, X0OptInfo &optVal); - void PropagateX0ForNextBb(BB *nextBb, X0OptInfo &optVal); + bool PropagateX0ForCurrBb(BB *bb, const X0OptInfo &optVal); + void PropagateX0ForNextBb(BB *nextBb, const X0OptInfo &optVal); void PropagateX0(); private: - CGFunc *cgFunc; + CGFunc *cgFunc; }; class AArch64RaOpt : public RaOpt { @@ -105,7 +104,6 @@ class AArch64RaOpt : public RaOpt { private: }; +} /* namespace maplebe */ -} // namespace maplebe - -#endif // MAPLEBE_INCLUDE_CG_AARCH64RAOPT_H +#endif /* MAPLEBE_INCLUDE_CG_AARCH64RAOPT_H */ diff --git a/src/mapleall/maple_be/include/cg/ra_opt.h b/src/mapleall/maple_be/include/cg/ra_opt.h index ee2a73f18d..1dd1395fda 100644 --- a/src/mapleall/maple_be/include/cg/ra_opt.h +++ b/src/mapleall/maple_be/include/cg/ra_opt.h @@ -43,4 +43,3 @@ CGFUNCPHASE(CgDoRaOpt, "raopt") } /* namespace maplebe */ #endif /* MAPLEBE_INCLUDE_CG_RAOPT_H */ - diff --git a/src/mapleall/maple_be/src/be/lower.cpp b/src/mapleall/maple_be/src/be/lower.cpp index 08a3234b63..b9bd3ed29a 100644 --- a/src/mapleall/maple_be/src/be/lower.cpp +++ b/src/mapleall/maple_be/src/be/lower.cpp @@ -1303,9 +1303,6 @@ bool CGLowerer::LowerStructReturn(BlockNode &newBlk, StmtNode *stmt, StmtNode *n regassign u64 %1 (regread u64 %%retval0) regassign ptr %2 (addrof ptr $s) iassign <* u64> 0 (regread ptr %2, regread u64 %1) */ - if (CGOptions::GetInstance().GetOptimizeLevel() == CGOptions::kLevel0) { - return false; - } MIRSymbol *symbol = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dnode_stmt->GetStIdx()); MIRStructType *structType = static_cast(symbol->GetType()); uint32 size = structType->GetSize(); diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp index 7336588d35..9b8c86a90a 100644 --- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp +++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp @@ -3427,6 +3427,28 @@ void AArch64CGFunc::SelectShift(Operand &resOpnd, Operand &opnd0, Operand &opnd1 GetCurBB()->AppendInsn(GetCG()->BuildInstruction(mopShift, resOpnd, *firstOpnd, opnd1)); } +Operand *AArch64CGFunc::SelectAbsSub(Insn &lastInsn, const UnaryNode &node, Operand &newOpnd0) { + PrimType dtyp = node.GetPrimType(); + bool is64Bits = (GetPrimTypeBitSize(dtyp) == k64BitSize); + /* promoted type */ + PrimType primType = is64Bits ? (PTY_i64) : (PTY_i32); + RegOperand &resOpnd = CreateRegisterOperandOfType(primType); + uint32 mopCsneg = is64Bits ? MOP_xcnegrrrc : MOP_wcnegrrrc; + /* ABS requires the operand be interpreted as a signed integer */ + CondOperand &condOpnd = GetCondOperand(CC_MI); + MOperator newMop = lastInsn.GetMachineOpcode() + 1; + Operand &rflag = GetOrCreateRflag(); + std::vector opndVec; + opndVec.push_back(&rflag); + for (uint32 i = 0; i < lastInsn.GetOperandSize(); i++) { + opndVec.push_back(&lastInsn.GetOperand(i)); + } + Insn *subsInsn = &GetCG()->BuildInstruction(newMop, opndVec); + GetCurBB()->ReplaceInsn(lastInsn, *subsInsn); + GetCurBB()->AppendInsn(GetCG()->BuildInstruction(mopCsneg, resOpnd, newOpnd0, condOpnd)); + return &resOpnd; +} + Operand *AArch64CGFunc::SelectAbs(UnaryNode &node, Operand &opnd0) { PrimType dtyp = node.GetPrimType(); if (IsPrimitiveFloat(dtyp)) { @@ -3441,8 +3463,13 @@ Operand *AArch64CGFunc::SelectAbs(UnaryNode &node, Operand &opnd0) { bool is64Bits = (GetPrimTypeBitSize(dtyp) == k64BitSize); /* promoted type */ PrimType primType = is64Bits ? (PTY_i64) : (PTY_i32); - RegOperand &resOpnd = CreateRegisterOperandOfType(primType); Operand &newOpnd0 = LoadIntoRegister(opnd0, primType); + Insn *lastInsn = GetCurBB()->GetLastInsn(); + if (lastInsn != nullptr && lastInsn->GetMachineOpcode() >= MOP_xsubrrr && + lastInsn->GetMachineOpcode() <= MOP_wsubrri12) { + return SelectAbsSub(*lastInsn, node, newOpnd0); + } + RegOperand &resOpnd = CreateRegisterOperandOfType(primType); SelectAArch64Cmp(newOpnd0, CreateImmOperand(0, is64Bits ? PTY_u64 : PTY_u32, false), true, GetPrimTypeBitSize(dtyp)); uint32 mopCsneg = is64Bits ? MOP_xcsnegrrrc : MOP_wcsnegrrrc; diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp index 5df3716a6a..81f57852c2 100644 --- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp +++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp @@ -662,6 +662,9 @@ void GraphColorRegAllocator::ClassifyOperand(std::unordered_set &pregs, } auto ®Opnd = static_cast(opnd); regno_t regNO = regOpnd.GetRegisterNumber(); + if (IsUnconcernedReg(regNO)) { + return; + } if (regOpnd.IsPhysicalRegister()) { (void)pregs.insert(regNO); } else { @@ -3298,12 +3301,12 @@ bool GraphColorRegAllocator::AllocateRegisters() { /* EBO propgation extent the live range and might need to be turned off. */ ComputeBlockOrder(); + InitCCReg(); + ComputeLiveRanges(); InitFreeRegPool(); - InitCCReg(); - BuildInterferenceGraph(); Separate(); diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_lsra.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_lsra.cpp index c50ce5fc59..9f778b3e8f 100644 --- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_lsra.cpp +++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_lsra.cpp @@ -20,6 +20,7 @@ #include "aarch64_operand.h" #include "aarch64_insn.h" #include "aarch64_cg.h" + namespace maplebe { /* * ================== diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp index 42fb4c66ec..a8d92666ee 100644 --- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp +++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp @@ -221,7 +221,7 @@ bool AArch64GenProEpilog::NeedProEpilog() { const MapleVector ®sToRestore = aarchCGFunc.GetCalleeSavedRegs(); size_t calleeSavedRegSize = kTwoRegister; CHECK_FATAL(regsToRestore.size() >= calleeSavedRegSize, "Forgot FP and LR ?"); - if (regsToRestore.size() > calleeSavedRegSize || aarchCGFunc.HasStackLoadStore() || HasLoop() || + if (regsToRestore.size() > calleeSavedRegSize || aarchCGFunc.HasStackLoadStore() || cgFunc.GetFunction().GetAttr(FUNCATTR_callersensitive)) { return true; } diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_ra_opt.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ra_opt.cpp index 9eca0506c4..96137867fc 100644 --- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_ra_opt.cpp +++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ra_opt.cpp @@ -18,13 +18,11 @@ #include namespace maplebe { - using namespace std; -//#define RAOPT_DUMP CG_DEBUG_FUNC(cgFunc) - -bool RaX0Opt::PropagateX0CanReplace(Operand *opnd, regno_t replaceReg) { - if (opnd) { - RegOperand *regopnd = static_cast(opnd); +/* #define RAOPT_DUMP CG_DEBUG_FUNC(cgFunc) */ +bool RaX0Opt::PropagateX0CanReplace(Operand *opnd, regno_t replaceReg) const { + if (opnd != nullptr) { + RegOperand *regopnd = static_cast(opnd); regno_t regCandidate = regopnd->GetRegisterNumber(); if (regCandidate == replaceReg) { return true; @@ -37,31 +35,31 @@ bool RaX0Opt::PropagateX0CanReplace(Operand *opnd, regno_t replaceReg) { * Replace replace_reg with rename_reg. * return true if there is a redefinition that needs to terminate the propagation. */ -bool RaX0Opt::PropagateRenameReg(Insn *nInsn, X0OptInfo &optVal) { - uint32 renameReg = static_cast(optVal.GetRenameOpnd())->GetRegisterNumber(); - const AArch64MD *md = &AArch64CG::kMd[static_cast (nInsn)->GetMachineOpcode()]; +bool RaX0Opt::PropagateRenameReg(Insn *nInsn, const X0OptInfo &optVal) { + uint32 renameReg = static_cast(optVal.GetRenameOpnd())->GetRegisterNumber(); + const AArch64MD *md = &AArch64CG::kMd[static_cast (nInsn)->GetMachineOpcode()]; int32 lastOpndId = nInsn->GetOperandSize() - 1; for (int32_t i = lastOpndId; i >= 0; i--) { Operand &opnd = nInsn->GetOperand(i); if (opnd.IsList()) { - // call parameters + /* call parameters */ } else if (opnd.IsMemoryAccessOperand()) { - MemOperand &memopnd = static_cast(opnd); + MemOperand &memopnd = static_cast(opnd); if (PropagateX0CanReplace(memopnd.GetBaseRegister(), optVal.GetReplaceReg())) { - RegOperand *renameOpnd = static_cast(optVal.GetRenameOpnd()); + RegOperand *renameOpnd = static_cast(optVal.GetRenameOpnd()); memopnd.SetBaseRegister(*renameOpnd); } if (PropagateX0CanReplace(memopnd.GetIndexRegister(), optVal.GetReplaceReg())) { - RegOperand *renameOpnd = static_cast(optVal.GetRenameOpnd()); + RegOperand *renameOpnd = static_cast(optVal.GetRenameOpnd()); memopnd.SetIndexRegister(*renameOpnd); } } else if (opnd.IsRegister()) { - bool isdef = static_cast(md->GetOperand(i))->IsRegDef(); - RegOperand ®opnd = static_cast(opnd); + bool isdef = static_cast(md->GetOperand(i))->IsRegDef(); + RegOperand ®opnd = static_cast(opnd); regno_t regCandidate = regopnd.GetRegisterNumber(); if (isdef) { - // Continue if both replace_reg & rename_reg are not redefined. + /* Continue if both replace_reg & rename_reg are not redefined. */ if (regCandidate == optVal.GetReplaceReg() || regCandidate == renameReg) { return true; } @@ -72,18 +70,18 @@ bool RaX0Opt::PropagateRenameReg(Insn *nInsn, X0OptInfo &optVal) { } } } - return false; // false == no redefinition + return false; /* false == no redefinition */ } -bool RaX0Opt::PropagateX0DetectX0(Insn *insn, X0OptInfo &optVal) { - /* Propagate x0 from a call return value to a def of x0. - * This eliminates some local reloads under high register pressure, since - * the use has been replaced by x0. - */ +/* Propagate x0 from a call return value to a def of x0. + * This eliminates some local reloads under high register pressure, since + * the use has been replaced by x0. + */ +bool RaX0Opt::PropagateX0DetectX0(const Insn *insn, X0OptInfo &optVal) { if (insn->GetMachineOpcode() != MOP_xmovrr && insn->GetMachineOpcode() != MOP_wmovrr) { return false; } - RegOperand &movSrc = static_cast(insn->GetOperand(1)); + RegOperand &movSrc = static_cast(insn->GetOperand(1)); if (movSrc.GetRegisterNumber() != R0) { return false; } @@ -92,11 +90,11 @@ bool RaX0Opt::PropagateX0DetectX0(Insn *insn, X0OptInfo &optVal) { return true; } -bool RaX0Opt::PropagateX0DetectRedefine(const AArch64MD *md, Insn *ninsn, const X0OptInfo &optVal, - uint32 index) { - bool isdef = static_cast(md->GetOperand(index))->IsRegDef(); +bool RaX0Opt::PropagateX0DetectRedefine(const AArch64MD *md, const Insn *ninsn, const X0OptInfo &optVal, + uint32 index) { + bool isdef = static_cast(md->GetOperand(index))->IsRegDef(); if (isdef) { - RegOperand &opnd = static_cast(ninsn->GetOperand(index)); + RegOperand &opnd = static_cast(ninsn->GetOperand(index)); if (opnd.GetRegisterNumber() == optVal.GetReplaceReg()) { return true; } @@ -106,20 +104,21 @@ bool RaX0Opt::PropagateX0DetectRedefine(const AArch64MD *md, Insn *ninsn, const bool RaX0Opt::PropagateX0Optimize(const BB *bb, const Insn *insn, X0OptInfo &optVal) { bool redefined = false; - for (Insn *ninsn = insn->GetNext(); ninsn && ninsn != bb->GetLastInsn()->GetNext(); ninsn = ninsn->GetNext()) { + for (Insn *ninsn = insn->GetNext(); (ninsn != nullptr) && ninsn != bb->GetLastInsn()->GetNext(); + ninsn = ninsn->GetNext()) { if (!ninsn->IsMachineInstruction()) { continue; } - // BB definition differences among C and other modules - // TODO remove this to extend to non standard BB + /* BB definition differences among C and other modules */ if (!cgFunc->GetMirModule().IsCModule() && ninsn->IsCall()) { break; } - // Will continue as long as the reg being replaced is not redefined. - // Does not need to check for x0 redefinition. The mov instruction src - // being replaced already defines x0 and will terminate this loop. + /* Will continue as long as the reg being replaced is not redefined. + * Does not need to check for x0 redefinition. The mov instruction src + * being replaced already defines x0 and will terminate this loop. + */ const AArch64MD *md = &AArch64CG::kMd[static_cast(ninsn)->GetMachineOpcode()]; for (uint32 i = 0; i < ninsn->GetResultNum(); i++) { redefined = PropagateX0DetectRedefine(md, ninsn, optVal, i); @@ -131,22 +130,22 @@ bool RaX0Opt::PropagateX0Optimize(const BB *bb, const Insn *insn, X0OptInfo &opt break; } - // Look for move where src is the register equivalent to x0. + /* Look for move where src is the register equivalent to x0. */ if (ninsn->GetMachineOpcode() != MOP_xmovrr && ninsn->GetMachineOpcode() != MOP_wmovrr) { continue; } Operand *src = &ninsn->GetOperand(1); - RegOperand *srcreg = static_cast(src); + RegOperand *srcreg = static_cast(src); if (srcreg->GetRegisterNumber() != optVal.GetReplaceReg()) { continue; } - // Setup for the next optmization pattern. + /* Setup for the next optmization pattern. */ Operand *dst = &ninsn->GetOperand(0); - RegOperand *dstreg = static_cast(dst); + RegOperand *dstreg = static_cast(dst); if (dstreg->GetRegisterNumber() != R0) { - // This is to set up for further propagation later. + /* This is to set up for further propagation later. */ if (srcreg->GetRegisterNumber() == optVal.GetReplaceReg()) { if (optVal.GetRenameInsn() != nullptr) { redefined = true; @@ -164,7 +163,7 @@ bool RaX0Opt::PropagateX0Optimize(const BB *bb, const Insn *insn, X0OptInfo &opt break; } - // x0 = x0 + /* x0 = x0 */ ninsn->SetOperand(1, *optVal.GetMovSrc()); break; } @@ -172,9 +171,10 @@ bool RaX0Opt::PropagateX0Optimize(const BB *bb, const Insn *insn, X0OptInfo &opt return redefined; } -bool RaX0Opt::PropagateX0ForCurrBb(BB *bb, X0OptInfo &optVal) { +bool RaX0Opt::PropagateX0ForCurrBb(BB *bb, const X0OptInfo &optVal) { bool redefined = false; - for (Insn *ninsn = optVal.GetRenameInsn()->GetNext(); ninsn && ninsn != bb->GetLastInsn()->GetNext(); ninsn = ninsn->GetNext()) { + for (Insn *ninsn = optVal.GetRenameInsn()->GetNext(); (ninsn != nullptr) && ninsn != bb->GetLastInsn()->GetNext(); + ninsn = ninsn->GetNext()) { if (!ninsn->IsMachineInstruction()) { continue; } @@ -188,13 +188,13 @@ bool RaX0Opt::PropagateX0ForCurrBb(BB *bb, X0OptInfo &optVal) { if (it != bb->GetLiveOutRegNO().end()) { bb->EraseLiveOutRegNO(it); } - uint32 renameReg = static_cast(optVal.GetRenameOpnd())->GetRegisterNumber(); + uint32 renameReg = static_cast(optVal.GetRenameOpnd())->GetRegisterNumber(); bb->InsertLiveOutRegNO(renameReg); } return redefined; } -void RaX0Opt::PropagateX0ForNextBb(BB *nextBb, X0OptInfo &optVal) { +void RaX0Opt::PropagateX0ForNextBb(BB *nextBb, const X0OptInfo &optVal) { bool redefined = false; for (Insn *ninsn = nextBb->GetFirstInsn(); ninsn != nextBb->GetLastInsn()->GetNext(); ninsn = ninsn->GetNext()) { if (!ninsn->IsMachineInstruction()) { @@ -215,16 +215,17 @@ void RaX0Opt::PropagateX0ForNextBb(BB *nextBb, X0OptInfo &optVal) { } } -// Perform optimization. -// First propagate x0 in a bb. -// Second propagation see comment in function. -//void RaX0Opt::PropagateX0(CGFunc *cgfunc) { +/* + * Perform optimization. + * First propagate x0 in a bb. + * Second propagation see comment in function. + */ void RaX0Opt::PropagateX0() { FOR_ALL_BB(bb, cgFunc) { X0OptInfo optVal; Insn *insn = bb->GetFirstInsn(); - while (insn && !insn->IsMachineInstruction()) { + while ((insn != nullptr) && !insn->IsMachineInstruction()) { insn = insn->GetNext(); continue; } @@ -235,13 +236,11 @@ void RaX0Opt::PropagateX0() { continue; } - // At this point the 1st insn is a mov from x0. - RegOperand &movDst = static_cast(insn->GetOperand(0)); + /* At this point the 1st insn is a mov from x0. */ + RegOperand &movDst = static_cast(insn->GetOperand(0)); optVal.SetReplaceReg(movDst.GetRegisterNumber()); - optVal.ResetRenameInsn(); bool redefined = PropagateX0Optimize(bb, insn, optVal); - if (redefined || (optVal.GetRenameInsn() == nullptr)) { continue; } @@ -258,10 +257,10 @@ void RaX0Opt::PropagateX0() { * reg2 not liveout * * Can allocate caller register for reg2. + * + * Further propagation of very short live interval cross bb reg */ - - // Further propagation of very short live interval cross bb reg - if (optVal.GetRenameReg() < kMaxRegNum) { // dont propagate physical reg + if (optVal.GetRenameReg() < kMaxRegNum) { /* dont propagate physical reg */ continue; } BB *nextBb = bb->GetNext(); @@ -279,14 +278,11 @@ void RaX0Opt::PropagateX0() { nextBb->GetLiveOutRegNO().find(optVal.GetReplaceReg()) != nextBb->GetLiveOutRegNO().end()) { continue; } - - // Replace replace_reg by rename_reg. + /* Replace replace_reg by rename_reg. */ redefined = PropagateX0ForCurrBb(bb, optVal); - if (redefined) { continue; } - PropagateX0ForNextBb(nextBb, optVal); } } @@ -295,5 +291,4 @@ void AArch64RaOpt::Run() { RaX0Opt x0Opt(cgFunc); x0Opt.PropagateX0(); } - -} // namespace maplebe +} /* namespace maplebe */ diff --git a/src/mapleall/maple_be/src/cg/cg_phasemanager.cpp b/src/mapleall/maple_be/src/cg/cg_phasemanager.cpp index 0fc2e3cdcc..bcbd60828b 100644 --- a/src/mapleall/maple_be/src/cg/cg_phasemanager.cpp +++ b/src/mapleall/maple_be/src/cg/cg_phasemanager.cpp @@ -38,6 +38,7 @@ #include "offset_adjust.h" #include "proepilog.h" #include "ra_opt.h" + namespace maplebe { #define JAVALANG (module.IsJavaModule()) #define CLANG (module.GetSrcLang() == kSrcLangC) @@ -133,11 +134,9 @@ void CgFuncPhaseManager::AddPhases(std::vector &phases) { if (CGOptions::DoPreSchedule()) { ADDPHASE("prescheduling"); } - - if (!CGOptions::DoPreLSRAOpt()) { - } else { - ADDPHASE("raopt"); - } + if (CGOptions::DoPreLSRAOpt()) { + ADDPHASE("raopt"); + } ADDPHASE("regalloc"); ADDPHASE("generateproepilog"); diff --git a/src/mapleall/maple_driver/defs/phases.def b/src/mapleall/maple_driver/defs/phases.def index cd56a45440..93b1211a16 100644 --- a/src/mapleall/maple_driver/defs/phases.def +++ b/src/mapleall/maple_driver/defs/phases.def @@ -22,6 +22,7 @@ ADD_PHASE("reflectionanalysis", JAVALANG) ADD_PHASE("GenNativeStubFunc", JAVALANG) ADD_PHASE("gencheckcast", JAVALANG) ADD_PHASE("javaintrnlowering", JAVALANG) +ADD_PHASE("simplify", Options::O2) ADD_PHASE("inline", Options::O2 && Options::useInline) // mephase begin ADD_PHASE("mecfgbuild", MeOption::optLevel >= 2 || JAVALANG) diff --git a/src/mapleall/maple_ipa/include/module_phases.def b/src/mapleall/maple_ipa/include/module_phases.def index 35bcd8dd9e..4f25d0b2ff 100644 --- a/src/mapleall/maple_ipa/include/module_phases.def +++ b/src/mapleall/maple_ipa/include/module_phases.def @@ -37,6 +37,7 @@ MODTPHASE(MoPhase_CHECKCASTGENERATION, DoCheckCastGeneration) MODTPHASE(MoPhase_CodeReLayout, DoCodeReLayout) MODTPHASE(MoPhase_SCALARREPLACEMENT, DoScalarReplacement) #endif +MODTPHASE(MoPhase_SIMPLIFY, DoSimplify) MODTPHASE(MoPhase_INLINE, DoInline) MODTPHASE(MoPhase_OPENPROFILE, DoOpenProfile) MODTPHASE(MoPhase_CONSTANTFOLD, DoConstantFold) diff --git a/src/mapleall/maple_ipa/src/module_phase_manager.cpp b/src/mapleall/maple_ipa/src/module_phase_manager.cpp index ed65f4a8c6..69df3be2f7 100644 --- a/src/mapleall/maple_ipa/src/module_phase_manager.cpp +++ b/src/mapleall/maple_ipa/src/module_phase_manager.cpp @@ -31,6 +31,7 @@ #include "annotation_analysis.h" #include "vtable_impl.h" #include "java_intrn_lowering.h" +#include "simplify.h" #include "java_eh_lower.h" #include "muid_replacement.h" #include "gen_check_cast.h" diff --git a/src/mapleall/maple_me/src/me_bb_layout.cpp b/src/mapleall/maple_me/src/me_bb_layout.cpp index dc9ed153c4..cea6be8a86 100644 --- a/src/mapleall/maple_me/src/me_bb_layout.cpp +++ b/src/mapleall/maple_me/src/me_bb_layout.cpp @@ -198,12 +198,18 @@ bool BBLayout::BBContainsOnlyGoto(const BB &bb) const { // The other case is fromBB has one predecessor and one successor and // contains only goto stmt. bool BBLayout::BBCanBeMoved(const BB &fromBB, const BB &toAfterBB) const { - if (fromBB.GetPred().size() > 1) { - return false; - } if (laidOut[fromBB.GetBBId()]) { return false; } + if (fromBB.GetPred().size() > 1) { + // additional condition: if all preds have been laidout, fromBB can be freely moved + for (auto *pred : fromBB.GetPred()) { + if (!laidOut[pred->GetBBId()]) { + return false; + } + } + } + if (fromBB.GetAttributes(kBBAttrArtificial) || (!fromBB.GetAttributes(kBBAttrIsTry) && !toAfterBB.GetAttributes(kBBAttrIsTry))) { return fromBB.GetSucc().size() == 1; @@ -378,7 +384,7 @@ BB *BBLayout::GetFallThruBBSkippingEmpty(BB &bb) { return fallthru; } if (func.GetIRMap() != nullptr) { - if (!fallthru->IsMeStmtEmpty()) { + if (!fallthru->IsMeStmtEmpty() && !BBContainsOnlyGoto(*fallthru)) { return fallthru; } } else { @@ -386,6 +392,10 @@ BB *BBLayout::GetFallThruBBSkippingEmpty(BB &bb) { return fallthru; } } + // in case of duplicate succ + if (fallthru->GetSucc().front() == bb.GetSucc().back()) { + return fallthru; + } laidOut[fallthru->GetBBId()] = true; BB *oldFallThru = fallthru; fallthru = fallthru->GetSucc().front(); diff --git a/src/mapleall/maple_me/src/me_loop_canon.cpp b/src/mapleall/maple_me/src/me_loop_canon.cpp index fcdb011383..f43603c795 100644 --- a/src/mapleall/maple_me/src/me_loop_canon.cpp +++ b/src/mapleall/maple_me/src/me_loop_canon.cpp @@ -273,7 +273,7 @@ void MeDoLoopCanon::ExecuteLoopCanon(MeFunction &func, MeFuncResultMgr &m, Domin } } -// Only when backege or preheader is not try bb, update head map. +// Only when backedge or preheader is not try bb, update head map. void MeDoLoopCanon::FindHeadBBs(MeFunction &func, Dominance &dom, const BB *bb) { if (bb == nullptr || bb == func.GetCfg()->GetCommonExitBB()) { return; @@ -281,7 +281,7 @@ void MeDoLoopCanon::FindHeadBBs(MeFunction &func, Dominance &dom, const BB *bb) bool hasTry = false; bool hasIgoto = false; for (BB *pred : bb->GetPred()) { - // backege or preheader is try bb + // backedge or preheader is try bb if (pred->GetAttributes(kBBAttrIsTry)) { hasTry = true; } @@ -296,7 +296,7 @@ void MeDoLoopCanon::FindHeadBBs(MeFunction &func, Dominance &dom, const BB *bb) } if ((!hasTry) && (!hasIgoto)) { for (BB *pred : bb->GetPred()) { - // add backege bb + // add backedge bb if (dom.Dominate(*bb, *pred)) { if (heads.find(bb->GetBBId()) != heads.end()) { heads[bb->GetBBId()].push_back(pred); @@ -345,7 +345,10 @@ void MeDoLoopCanon::Merge(MeFunction &func) { for (auto iter = heads.begin(); iter != heads.end(); ++iter) { BB *head = cfg->GetBBFromID(iter->first); // skip case : check latch bb is already added + // one pred is preheader bb and the other is latch bb if ((head->GetPred().size() == 2) && + (head->GetPred(0)->GetAttributes(kBBAttrArtificial)) && + (head->GetPred(0)->GetKind() == kBBFallthru) && (head->GetPred(1)->GetAttributes(kBBAttrArtificial)) && (head->GetPred(1)->GetKind() == kBBFallthru)) { continue; diff --git a/src/mapleall/maple_me/src/ssa_pre.cpp b/src/mapleall/maple_me/src/ssa_pre.cpp index c64af6e07d..6b7130ec19 100644 --- a/src/mapleall/maple_me/src/ssa_pre.cpp +++ b/src/mapleall/maple_me/src/ssa_pre.cpp @@ -48,24 +48,7 @@ ScalarMeExpr *SSAPre::CreateNewCurTemp(const MeExpr &meExpr) { if (workCand->GetPUIdx() != 0) { // allocate a new temp SetCurFunction(workCand->GetPUIdx()); - RegMeExpr *regVar = nullptr; - if (meExpr.GetMeOp() == kMeOpIvar) { - auto *ivarMeExpr = static_cast(&meExpr); - MIRType *ptrMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr->GetTyIdx()); - CHECK_FATAL(ptrMIRType->GetKind() == kTypePointer, "must be point type for ivar"); - auto *realMIRType = static_cast(ptrMIRType); - FieldID fieldId = ivarMeExpr->GetFieldID(); - MIRType *ty = nullptr; - if (fieldId > 0) { - ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(realMIRType->GetPointedTyIdxWithFieldID(fieldId)); - } else { - ty = realMIRType->GetPointedType(); - } - regVar = (ty->GetPrimType() == PTY_ref) ? (irMap->CreateRegMeExpr(*ty)) - : (irMap->CreateRegMeExpr(ivarMeExpr->GetPrimType())); - } else { - regVar = irMap->CreateRegMeExpr(meExpr); - } + RegMeExpr *regVar = irMap->CreateRegMeExpr(meExpr); curTemp = regVar; if (preKind == kLoadPre) { irMap->SetLpreTmps(static_cast(&meExpr)->GetOstIdx(), *regVar); diff --git a/src/mapleall/mpl2mpl/BUILD.gn b/src/mapleall/mpl2mpl/BUILD.gn index c2c299619c..c5ad777543 100755 --- a/src/mapleall/mpl2mpl/BUILD.gn +++ b/src/mapleall/mpl2mpl/BUILD.gn @@ -32,6 +32,7 @@ src_libmpl2mpl = [ "src/reflection_analysis.cpp", "src/vtable_analysis.cpp", "src/java_intrn_lowering.cpp", + "src/simplify.cpp", "src/java_eh_lower.cpp", "src/native_stub_func.cpp", "src/vtable_impl.cpp", diff --git a/src/mapleall/mpl2mpl/include/simplify.h b/src/mapleall/mpl2mpl/include/simplify.h new file mode 100644 index 0000000000..0b88d584f7 --- /dev/null +++ b/src/mapleall/mpl2mpl/include/simplify.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan PSL v1. + * You can use this software according to the terms and conditions of the Mulan PSL v1. + * You may obtain a copy of Mulan PSL v1 at: + * + * http://license.coscl.org.cn/MulanPSL + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v1 for more details. + */ +#ifndef MPL2MPL_INCLUDE_SIMPLIFY_H +#define MPL2MPL_INCLUDE_SIMPLIFY_H +#include "module_phase.h" +#include "phase_impl.h" +#include "factory.h" +namespace maple { +class Simplify : public FuncOptimizeImpl { + public: + Simplify(MIRModule &mod, KlassHierarchy *kh, bool dump) : FuncOptimizeImpl(mod, kh, dump), mirMod(mod) { + } + Simplify(const Simplify &other) = delete; + Simplify &operator=(const Simplify &other) = delete; + ~Simplify() = default; + FuncOptimizeImpl *Clone() override { + CHECK_FATAL(false, "Simplify has pointer, should not be Cloned"); + } + + void ProcessFunc(MIRFunction *func) override; + void ProcessFuncStmt(MIRFunction &func, StmtNode *stmt = nullptr, BlockNode *block = nullptr); + void Finish() override; + + private: + MIRModule &mirMod; + bool IsMathSqrt(const std::string funcName); + bool IsMathAbs(const std::string funcName); + bool IsMathMin(const std::string funcName); + bool IsMathMax(const std::string funcName); + bool SimplifyMathMethod(const StmtNode &stmt, BlockNode &block); + void SimplifyCallAssigned(const StmtNode &stmt, BlockNode &block); +}; +class DoSimplify : public ModulePhase { + public: + explicit DoSimplify(ModulePhaseID id) : ModulePhase(id) {} + + std::string PhaseName() const override { + return "simplify"; + } + + AnalysisResult *Run(MIRModule *mod, ModuleResultMgr *mrm) override { + OPT_TEMPLATE(Simplify); + return nullptr; + } + + ~DoSimplify() = default; +}; +} // namespace maple +#endif // MPL2MPL_INCLUDE_SIMPLIFY_H diff --git a/src/mapleall/mpl2mpl/src/simplify.cpp b/src/mapleall/mpl2mpl/src/simplify.cpp new file mode 100644 index 0000000000..664dabea84 --- /dev/null +++ b/src/mapleall/mpl2mpl/src/simplify.cpp @@ -0,0 +1,154 @@ +/* + * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan PSL v1. + * You can use this software according to the terms and conditions of the Mulan PSL v1. + * You may obtain a copy of Mulan PSL v1 at: + * + * http://license.coscl.org.cn/MulanPSL + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v1 for more details. + */ +#include "simplify.h" +#include +#include + +namespace { +constexpr char kClassNameOfMath[] = "Ljava_2Flang_2FMath_3B"; +constexpr char kFuncNamePrefixOfMathSqrt[] = "Ljava_2Flang_2FMath_3B_7Csqrt_7C_28D_29D"; +constexpr char kFuncNamePrefixOfMathAbs[] = "Ljava_2Flang_2FMath_3B_7Cabs_7C"; +constexpr char kFuncNamePrefixOfMathMax[] = "Ljava_2Flang_2FMath_3B_7Cmax_7C"; +constexpr char kFuncNamePrefixOfMathMin[] = "Ljava_2Flang_2FMath_3B_7Cmin_7C"; +constexpr char kFuncNameOfMathSqrt[] = "sqrt"; +constexpr char kFuncNameOfMathAbs[] = "abs"; +constexpr char kFuncNameOfMathMax[] = "max"; +constexpr char kFuncNameOfMathMin[] = "min"; +} // namespace + +namespace maple { +bool Simplify::IsMathSqrt(const std::string funcName) { + return (mirMod.IsCModule() && (strcmp(funcName.c_str(), kFuncNameOfMathSqrt) == 0)) || + (mirMod.IsJavaModule() && (strcmp(funcName.c_str(), kFuncNamePrefixOfMathSqrt) == 0)); +} + +bool Simplify::IsMathAbs(const std::string funcName) { + return (mirMod.IsCModule() && (strcmp(funcName.c_str(), kFuncNameOfMathAbs) == 0)) || + (mirMod.IsJavaModule() && (strcmp(funcName.c_str(), kFuncNamePrefixOfMathAbs) == 0)); +} + +bool Simplify::IsMathMax(const std::string funcName) { + return (mirMod.IsCModule() && (strcmp(funcName.c_str(), kFuncNameOfMathMax) == 0)) || + (mirMod.IsJavaModule() && (strcmp(funcName.c_str(), kFuncNamePrefixOfMathMax) == 0)); +} + +bool Simplify::IsMathMin(const std::string funcName) { + return (mirMod.IsCModule() && (strcmp(funcName.c_str(), kFuncNameOfMathMin) == 0)) || + (mirMod.IsJavaModule() && (strcmp(funcName.c_str(), kFuncNamePrefixOfMathMin) == 0)); +} + +bool Simplify::SimplifyMathMethod(const StmtNode &stmt, BlockNode &block) { + if (stmt.GetOpCode() != OP_callassigned) { + return false; + } + auto &cnode = static_cast(stmt); + MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(cnode.GetPUIdx()); + ASSERT(calleeFunc != nullptr, "null ptr check"); + const std::string &funcName = calleeFunc->GetName(); + if (funcName.empty()) { + return false; + } + if (!mirMod.IsCModule() && !mirMod.IsJavaModule()) { + return false; + } + if (mirMod.IsJavaModule() && funcName.find(kClassNameOfMath) == std::string::npos) { + return false; + } + if (cnode.GetNumOpnds() == 0 || cnode.GetReturnVec().empty()) { + return false; + } + + auto *opnd0 = cnode.Opnd(0); + ASSERT(opnd0 != nullptr, "null ptr check"); + auto *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(opnd0->GetPrimType()); + + BaseNode *opExpr = nullptr; + if (IsMathSqrt(funcName) && !IsPrimitiveFloat(opnd0->GetPrimType())) { + opExpr = builder->CreateExprUnary(OP_sqrt, *type, opnd0); + } else if (IsMathAbs(funcName)) { + opExpr = builder->CreateExprUnary(OP_abs, *type, opnd0); + } else if (IsMathMax(funcName)) { + opExpr = builder->CreateExprBinary(OP_max, *type, opnd0, cnode.Opnd(1)); + } else if (IsMathMin(funcName)) { + opExpr = builder->CreateExprBinary(OP_min, *type, opnd0, cnode.Opnd(1)); + } + if (opExpr != nullptr) { + auto stIdx = cnode.GetNthReturnVec(0).first; + auto *dassign = builder->CreateStmtDassign(stIdx, 0, opExpr); + block.ReplaceStmt1WithStmt2(&stmt, dassign); + return true; + } + return false; +} + +void Simplify::SimplifyCallAssigned(const StmtNode &stmt, BlockNode &block) { + if (SimplifyMathMethod(stmt, block)) { + return; + } +} + +void Simplify::ProcessFunc(MIRFunction *func) { + if (func->IsEmpty()) { + return; + } + SetCurrentFunction(*func); + ProcessFuncStmt(*func); +} + +void Simplify::ProcessFuncStmt(MIRFunction &func, StmtNode *stmt, BlockNode *block) { + StmtNode *next = nullptr; + if (block == nullptr) { + block = func.GetBody(); + } + if (stmt == nullptr) { + stmt = (block == nullptr) ? nullptr : block->GetFirst(); + } + while (stmt != nullptr) { + next = stmt->GetNext(); + Opcode op = stmt->GetOpCode(); + switch (op) { + case OP_if: { + IfStmtNode *ifNode = static_cast(stmt); + if (ifNode->GetThenPart() != nullptr && ifNode->GetThenPart()->GetFirst() != nullptr) { + ProcessFuncStmt(func, ifNode->GetThenPart()->GetFirst(), ifNode->GetThenPart()); + } + if (ifNode->GetElsePart() != nullptr && ifNode->GetElsePart()->GetFirst() != nullptr) { + ProcessFuncStmt(func, ifNode->GetElsePart()->GetFirst(), ifNode->GetElsePart()); + } + break; + } + case OP_dowhile: + case OP_while: { + WhileStmtNode *whileNode = static_cast(stmt); + if (whileNode->GetBody() != nullptr) { + ProcessFuncStmt(func, whileNode->GetBody()->GetFirst(), whileNode->GetBody()); + } + break; + } + case OP_callassigned: { + SimplifyCallAssigned(*stmt, *block); + break; + } + default: { + break; + } + } + stmt = next; + } +} + +void Simplify::Finish() { +} +} // namespace maple diff --git a/src/mplfe/ast_input/include/ast_builtin_func.def b/src/mplfe/ast_input/include/ast_builtin_func.def index f6a92a9ceb..c629fb8cc1 100644 --- a/src/mplfe/ast_input/include/ast_builtin_func.def +++ b/src/mplfe/ast_input/include/ast_builtin_func.def @@ -21,4 +21,3 @@ BUILTIN_FUNC(bswap16) BUILTIN_FUNC(mul_overflow) // not support builtin func BUILTIN_FUNC(clzl) -BUILTIN_FUNC(prefetch) diff --git a/src/mplfe/ast_input/include/ast_decl.h b/src/mplfe/ast_input/include/ast_decl.h index 646920bf9a..ea54ea55ef 100644 --- a/src/mplfe/ast_input/include/ast_decl.h +++ b/src/mplfe/ast_input/include/ast_decl.h @@ -134,6 +134,7 @@ class ASTFunc : public ASTDecl { compound = nullptr; } void SetCompoundStmt(ASTStmt*); + void InsertStmtsIntoCompoundStmtAtFront(const std::list &stmts); const ASTStmt *GetCompoundStmt() const; const std::vector &GetParmNames() const { return parmNames; diff --git a/src/mplfe/ast_input/include/ast_expr.h b/src/mplfe/ast_input/include/ast_expr.h index 1593c5790a..02947e5f09 100644 --- a/src/mplfe/ast_input/include/ast_expr.h +++ b/src/mplfe/ast_input/include/ast_expr.h @@ -242,6 +242,9 @@ class ASTUnaryOperatorExpr : public ASTExpr { return isGlobal; } + UniqueFEIRExpr ASTUOSideEffectExpr(Opcode op, std::list &stmts, + std::string varName = "", bool post = false) const; + protected: bool isGlobal = false; ASTExpr *expr = nullptr; @@ -711,43 +714,29 @@ class ASTArraySubscriptExpr : public ASTExpr { } void SetBaseExprType(MIRType *ty) { - baseExprTypes.push_back(ty); + baseExprTypes.emplace_back(ty); } const std::vector &GetBaseExprType() const { return baseExprTypes; } - int32 TranslateArraySubscript2Offset() const; - - void SetMemberExpr(ASTExpr &astExpr) { - memberExpr = &astExpr; - } - - ASTExpr* GetMemberExpr() const { - return memberExpr; + void SetArrayType(MIRType *ty) { + arrayType = ty; } - std::string GetBaseExprVarName() const { - return baseExprVarName; + const MIRType *GetArrayType() const { + return arrayType; } - void SetBaseExprVarName(std::string argBaseExprVarName) { - baseExprVarName = argBaseExprVarName; - } - - void SetAddrOfFlag(bool flag) { - isAddrOf = flag; - } + int32 TranslateArraySubscript2Offset() const; private: UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; ASTExpr *baseExpr = nullptr; - ASTExpr *memberExpr = nullptr; + MIRType *arrayType = nullptr; std::vector baseExprTypes; std::vector idxExprs; - bool isAddrOf = false; - std::string baseExprVarName; }; class ASTExprUnaryExprOrTypeTraitExpr : public ASTExpr { @@ -823,8 +812,6 @@ class ASTMemberExpr : public ASTExpr { private: UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; - void Emit2FEExprImplForArrayElemIsStruct(UniqueFEIRExpr baseFEExpr, std::string &tmpStructName, - std::list &stmts) const; ASTExpr *baseExpr = nullptr; std::string memberName; MIRType *memberType = nullptr; @@ -879,11 +866,6 @@ class ASTAssignExpr : public ASTBinaryOperatorExpr { isCompoundAssign = argIsCompoundAssign; } - protected: - UniqueFEIRExpr ProcessAssign(std::list &stmts, UniqueFEIRExpr leftExpr, - UniqueFEIRExpr rightExpr) const; - void ProcessAssign4ExprArrayStoreForC(std::list &stmts, UniqueFEIRExpr leftFEExpr, - UniqueFEIRExpr rightFEExpr) const; private: UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; bool isCompoundAssign; diff --git a/src/mplfe/ast_input/include/ast_op.h b/src/mplfe/ast_input/include/ast_op.h index b793ba48ab..cc4f125711 100644 --- a/src/mplfe/ast_input/include/ast_op.h +++ b/src/mplfe/ast_input/include/ast_op.h @@ -126,6 +126,8 @@ enum ASTOp { }; enum ASTStmtOp { + kASTStmtNone, + kASTStmtDummy, // branch kASTStmtIf, kASTStmtGoto, diff --git a/src/mplfe/ast_input/include/ast_parser.h b/src/mplfe/ast_input/include/ast_parser.h index 2d38aca32e..91429d1afe 100644 --- a/src/mplfe/ast_input/include/ast_parser.h +++ b/src/mplfe/ast_input/include/ast_parser.h @@ -85,10 +85,12 @@ class ASTParser { // ProcessExpr const clang::Expr *PeelParen(const clang::Expr &expr); + const clang::Expr *PeelParen2(const clang::Expr &expr); ASTUnaryOperatorExpr *AllocUnaryOperatorExpr(MapleAllocator &allocator, const clang::UnaryOperator &expr); ASTValue *AllocASTValue(MapleAllocator &allocator) const; ASTValue *TranslateExprEval(MapleAllocator &allocator, const clang::Expr *expr) const; ASTExpr *ProcessExpr(MapleAllocator &allocator, const clang::Expr *expr); + ASTExpr *ProcessExprInType(MapleAllocator &allocator, const clang::QualType &qualType); ASTBinaryOperatorExpr *AllocBinaryOperatorExpr(MapleAllocator &allocator, const clang::BinaryOperator &bo); #define PROCESS_EXPR(CLASS) ProcessExpr##CLASS(MapleAllocator&, const clang::CLASS&) ASTExpr *PROCESS_EXPR(UnaryOperator); diff --git a/src/mplfe/ast_input/include/ast_stmt.h b/src/mplfe/ast_input/include/ast_stmt.h index 9edd78f652..9c9e25a026 100644 --- a/src/mplfe/ast_input/include/ast_stmt.h +++ b/src/mplfe/ast_input/include/ast_stmt.h @@ -22,7 +22,7 @@ namespace maple { class ASTDecl; class ASTStmt { public: - explicit ASTStmt(ASTStmtOp o) : op(o) {} + explicit ASTStmt(ASTStmtOp o = kASTStmtNone) : op(o) {} virtual ~ASTStmt() = default; void SetASTExpr(ASTExpr* astExpr); @@ -60,11 +60,21 @@ class ASTStmt { uint32 srcFileLineNum = 0; }; +class ASTStmtDummy : public ASTStmt { + public: + ASTStmtDummy() : ASTStmt(kASTStmtDummy) {} + ~ASTStmtDummy() = default; + + private: + std::list Emit2FEStmtImpl() const override; +}; + class ASTCompoundStmt : public ASTStmt { public: ASTCompoundStmt() : ASTStmt(kASTStmtCompound) {} ~ASTCompoundStmt() = default; void SetASTStmt(ASTStmt*); + void InsertASTStmtsAtFront(const std::list &stmts); const std::list &GetASTStmtList() const; private: @@ -500,6 +510,7 @@ class ASTCallExprStmt : public ASTStmt { std::list ProcessBuiltinVaStart() const; std::list ProcessBuiltinVaEnd() const; std::list ProcessBuiltinVaCopy() const; + std::list ProcessBuiltinPrefetch() const; static std::map funcPtrMap; std::string varName; diff --git a/src/mplfe/ast_input/lib/ast_interface.cpp b/src/mplfe/ast_input/lib/ast_interface.cpp index 65800a4c5d..f55e0ddb0f 100644 --- a/src/mplfe/ast_input/lib/ast_interface.cpp +++ b/src/mplfe/ast_input/lib/ast_interface.cpp @@ -48,7 +48,7 @@ const AstASTContext *LibAstFile::GetAstContext() { return astContext; } -AstASTContext *LibAstFile::GetNonConstAstContext() { +AstASTContext *LibAstFile::GetNonConstAstContext() const { return astContext; } diff --git a/src/mplfe/ast_input/lib/ast_interface.h b/src/mplfe/ast_input/lib/ast_interface.h index bb5fe53b17..92674bc35b 100644 --- a/src/mplfe/ast_input/lib/ast_interface.h +++ b/src/mplfe/ast_input/lib/ast_interface.h @@ -38,7 +38,7 @@ class LibAstFile { bool Open(const std::string &fileName, int excludeDeclFromPCH, int displayDiagnostics); const AstASTContext *GetAstContext(); - AstASTContext *GetNonConstAstContext(); + AstASTContext *GetNonConstAstContext() const; AstUnitDecl *GetAstUnitDecl(); std::string GetMangledName(const clang::NamedDecl &decl); const std::string GetOrCreateMappedUnnamedName(uint32_t id); diff --git a/src/mplfe/ast_input/src/ast_decl.cpp b/src/mplfe/ast_input/src/ast_decl.cpp index 03b31b8e09..d1d9b48fbf 100644 --- a/src/mplfe/ast_input/src/ast_decl.cpp +++ b/src/mplfe/ast_input/src/ast_decl.cpp @@ -140,6 +140,10 @@ void ASTFunc::SetCompoundStmt(ASTStmt *astCompoundStmt) { compound = astCompoundStmt; } +void ASTFunc::InsertStmtsIntoCompoundStmtAtFront(const std::list &stmts) { + static_cast(compound)->InsertASTStmtsAtFront(stmts); +} + const ASTStmt *ASTFunc::GetCompoundStmt() const { return compound; } diff --git a/src/mplfe/ast_input/src/ast_expr.cpp b/src/mplfe/ast_input/src/ast_expr.cpp index c4e768b062..804198fc76 100644 --- a/src/mplfe/ast_input/src/ast_expr.cpp +++ b/src/mplfe/ast_input/src/ast_expr.cpp @@ -374,11 +374,19 @@ UniqueFEIRExpr ASTImplicitCastExpr::Emit2FEExprImpl(std::list &s const ASTExpr *childExpr = child; UniqueFEIRType srcType = std::make_unique(*src); CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); - if(isArrayToPointerDecay) { + if (isArrayToPointerDecay) { if (child->GetASTOp() == kASTStringLiteral) { static_cast(child)->SetIsArrayToPointerDecay(true); - } else if (child->GetASTOp() == kASTSubscriptExpr) { - static_cast(child)->SetAddrOfFlag(true); + } + auto childFEExpr = childExpr->Emit2FEExpr(stmts); + if (childFEExpr->GetKind() == kExprIRead) { + auto iread = static_cast(childFEExpr.get()); + if (iread->GetFieldID() == 0) { + return iread->GetClonedOpnd(); + } else { + return std::make_unique(iread->GetClonedPtrType(), iread->GetFieldID(), + iread->GetClonedOpnd()); + } } } UniqueFEIRExpr subExpr = childExpr->Emit2FEExpr(stmts); @@ -455,185 +463,45 @@ UniqueFEIRExpr ASTUOLNotExpr::Emit2FEExprImpl(std::list &stmts) return std::make_unique(OP_lnot, subType, std::move(childFEIRExpr)); } -UniqueFEIRExpr ASTUOPostIncExpr::Emit2FEExprImpl(std::list &stmts) const { +UniqueFEIRExpr ASTUnaryOperatorExpr::ASTUOSideEffectExpr(Opcode op, std::list &stmts, + std::string varName, bool post) const { ASTExpr *childExpr = expr; CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); - UniqueFEIRExpr readSelfExpr; - UniqueFEIRVar selfVar; - if (childExpr->GetASTOp() == kASTMemberExpr || childExpr->GetASTOp() == kASTOpDeref || - childExpr->GetASTOp() == kASTSubscriptExpr) { - readSelfExpr = childFEIRExpr->Clone(); - } else { - selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false); - readSelfExpr = FEIRBuilder::CreateExprDRead(selfVar->Clone()); + UniqueFEIRVar tempVar; + if (post) { + tempVar = FEIRBuilder::CreateVarNameForC(varName, *subType); + UniqueFEIRStmt readSelfstmt = FEIRBuilder::CreateStmtDAssign(tempVar->Clone(), childFEIRExpr->Clone()); + stmts.emplace_back(std::move(readSelfstmt)); } - UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(tempVarName, *subType); - UniqueFEIRStmt readSelfstmt = FEIRBuilder::CreateStmtDAssign(tempVar->Clone(), std::move(readSelfExpr)); - stmts.emplace_back(std::move(readSelfstmt)); + PrimType subPrimType = subType->GetPrimType(); - UniqueFEIRExpr incIecExpr = (subPrimType == PTY_ptr) ? std::make_unique(pointeeLen, PTY_i32) : - FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); - UniqueFEIRExpr selfAddExpr = FEIRBuilder::CreateExprMathBinary(OP_add, childFEIRExpr->Clone(), - std::move(incIecExpr)); - UniqueFEIRStmt selfAddStmt; - if (childExpr->GetASTOp() == kASTMemberExpr || childExpr->GetASTOp() == kASTOpDeref) { - auto ireadFEExpr = static_cast(childFEIRExpr.get()); - selfAddStmt = std::make_unique(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(), - std::move(selfAddExpr), ireadFEExpr->GetFieldID()); - } else if (childExpr->GetASTOp() == kASTSubscriptExpr) { - auto ireadFEExpr = static_cast(childFEIRExpr.get()); - auto indexFEExpr = ireadFEExpr->GetExprIndexs().front()->Clone(); - MIRType *mirArrayType = ireadFEExpr->GetTypeArray().GenerateMIRTypeAuto(); - MIRType *elemType = static_cast(mirArrayType)->GetElemType(); - MIRType *ptrMIRElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType, PTY_ptr); - auto ptrFEArrayType = std::make_unique(*ptrMIRElemType); - auto arrayExpr = FEIRBuilder::CreateExprAddrofArray(ireadFEExpr->GetUniqueTypeArray()->Clone(), - ireadFEExpr->GetUniqueExprArray()->Clone(), - ireadFEExpr->GetArrayName(), - ireadFEExpr->GetExprIndexs()); - selfAddStmt = std::make_unique(std::move(ptrFEArrayType), - std::move(arrayExpr), - std::move(selfAddExpr), 0); - } else { - selfAddStmt = FEIRBuilder::CreateStmtDAssign(std::move(selfVar), std::move(selfAddExpr)); + UniqueFEIRExpr subExpr = (subPrimType == PTY_ptr) ? std::make_unique(pointeeLen, PTY_i32) : + FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); + UniqueFEIRExpr sideEffectExpr = FEIRBuilder::CreateExprMathBinary(op, childFEIRExpr->Clone(), std::move(subExpr)); + UniqueFEIRStmt sideEffectStmt = FEIRBuilder::AssginStmtField(childFEIRExpr->Clone(), std::move(sideEffectExpr), 0); + stmts.emplace_back(std::move(sideEffectStmt)); + + if (post) { + return FEIRBuilder::CreateExprDRead(std::move(tempVar)); } - stmts.emplace_back(std::move(selfAddStmt)); - UniqueFEIRExpr readTempExpr = FEIRBuilder::CreateExprDRead(std::move(tempVar)); - return readTempExpr; + return childFEIRExpr; +} + +UniqueFEIRExpr ASTUOPostIncExpr::Emit2FEExprImpl(std::list &stmts) const { + return ASTUOSideEffectExpr(OP_add, stmts, tempVarName, true); } UniqueFEIRExpr ASTUOPostDecExpr::Emit2FEExprImpl(std::list &stmts) const { - ASTExpr *childExpr = expr; - CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); - UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); - UniqueFEIRExpr readSelfExpr; - UniqueFEIRVar selfVar; - if (childExpr->GetASTOp() == kASTMemberExpr || childExpr->GetASTOp() == kASTOpDeref || - childExpr->GetASTOp() == kASTSubscriptExpr) { - readSelfExpr = childFEIRExpr->Clone(); - } else { - selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false); - readSelfExpr = FEIRBuilder::CreateExprDRead(selfVar->Clone()); - } - UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(tempVarName, *subType); - UniqueFEIRVar tempMoveVar = tempVar->Clone(); - UniqueFEIRStmt readSelfstmt = FEIRBuilder::CreateStmtDAssign(std::move(tempMoveVar), std::move(readSelfExpr)); - stmts.emplace_back(std::move(readSelfstmt)); - PrimType subPrimType = subType->GetPrimType(); - UniqueFEIRExpr incDecExpr = (subPrimType == PTY_ptr) ? std::make_unique(pointeeLen, PTY_i32) : - FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); - UniqueFEIRExpr selfSubExpr = FEIRBuilder::CreateExprMathBinary(OP_sub, childFEIRExpr->Clone(), - std::move(incDecExpr)); - UniqueFEIRStmt selfSubStmt; - if (childExpr->GetASTOp() == kASTMemberExpr || childExpr->GetASTOp() == kASTOpDeref) { - auto ireadFEExpr = static_cast(childFEIRExpr.get()); - selfSubStmt = std::make_unique(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(), - std::move(selfSubExpr), ireadFEExpr->GetFieldID()); - } else if (childExpr->GetASTOp() == kASTSubscriptExpr) { - auto ireadFEExpr = static_cast(childFEIRExpr.get()); - auto indexFEExpr = ireadFEExpr->GetExprIndexs().front()->Clone(); - MIRType *mirArrayType = ireadFEExpr->GetTypeArray().GenerateMIRTypeAuto(); - MIRType *elemType = static_cast(mirArrayType)->GetElemType(); - MIRType *ptrMIRElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType, PTY_ptr); - auto ptrFEArrayType = std::make_unique(*ptrMIRElemType); - auto arrayExpr = FEIRBuilder::CreateExprAddrofArray(ireadFEExpr->GetUniqueTypeArray()->Clone(), - ireadFEExpr->GetUniqueExprArray()->Clone(), - ireadFEExpr->GetArrayName(), - ireadFEExpr->GetExprIndexs()); - selfSubStmt = std::make_unique(std::move(ptrFEArrayType), - std::move(arrayExpr), - std::move(selfSubExpr), 0); - } else { - selfSubStmt = FEIRBuilder::CreateStmtDAssign(std::move(selfVar), std::move(selfSubExpr)); - } - stmts.emplace_back(std::move(selfSubStmt)); - UniqueFEIRExpr readTempExpr = FEIRBuilder::CreateExprDRead(std::move(tempVar)); - return readTempExpr; + return ASTUOSideEffectExpr(OP_sub, stmts, tempVarName, true); } UniqueFEIRExpr ASTUOPreIncExpr::Emit2FEExprImpl(std::list &stmts) const { - ASTExpr *childExpr = expr; - CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); - UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); - PrimType subPrimType = subType->GetPrimType(); - UniqueFEIRExpr incIecExpr = (subPrimType == PTY_ptr) ? std::make_unique(pointeeLen, PTY_i32) : - FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); - UniqueFEIRExpr astUOPreIncExpr = FEIRBuilder::CreateExprMathBinary(OP_add, childFEIRExpr->Clone(), - std::move(incIecExpr)); - UniqueFEIRStmt stmt; - UniqueFEIRExpr retExpr; - if (childExpr->GetASTOp() == kASTMemberExpr || childExpr->GetASTOp() == kASTOpDeref) { - auto ireadFEExpr = static_cast(childFEIRExpr.get()); - stmt = std::make_unique(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(), - std::move(astUOPreIncExpr), ireadFEExpr->GetFieldID()); - retExpr = std::move(childFEIRExpr); - } else if (childExpr->GetASTOp() == kASTSubscriptExpr) { - auto ireadFEExpr = static_cast(childFEIRExpr.get()); - auto indexFEExpr = ireadFEExpr->GetExprIndexs().front()->Clone(); - MIRType *mirArrayType = ireadFEExpr->GetTypeArray().GenerateMIRTypeAuto(); - MIRType *elemType = static_cast(mirArrayType)->GetElemType(); - MIRType *ptrMIRElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType, PTY_ptr); - auto ptrFEArrayType = std::make_unique(*ptrMIRElemType); - auto arrayExpr = FEIRBuilder::CreateExprAddrofArray(ireadFEExpr->GetUniqueTypeArray()->Clone(), - ireadFEExpr->GetUniqueExprArray()->Clone(), - ireadFEExpr->GetArrayName(), - ireadFEExpr->GetExprIndexs()); - stmt = std::make_unique(std::move(ptrFEArrayType), - std::move(arrayExpr), - std::move(astUOPreIncExpr), 0); - retExpr = std::move(childFEIRExpr); - } else { - UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), - *subType, isGlobal, false); - UniqueFEIRVar selfMoveVar = selfVar->Clone(); - stmt = FEIRBuilder::CreateStmtDAssign(std::move(selfMoveVar), std::move(astUOPreIncExpr)); - retExpr = FEIRBuilder::CreateExprDRead(std::move(selfVar)); - } - stmts.emplace_back(std::move(stmt)); - return retExpr; + return ASTUOSideEffectExpr(OP_add, stmts); } UniqueFEIRExpr ASTUOPreDecExpr::Emit2FEExprImpl(std::list &stmts) const { - ASTExpr *childExpr = expr; - CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); - UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); - PrimType subPrimType = subType->GetPrimType(); - UniqueFEIRExpr incDecExpr = (subPrimType == PTY_ptr) ? std::make_unique(pointeeLen, PTY_i32) : - FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); - UniqueFEIRExpr astUOPreDecExpr = FEIRBuilder::CreateExprMathBinary(OP_sub, childFEIRExpr->Clone(), - std::move(incDecExpr)); - UniqueFEIRStmt stmt; - UniqueFEIRExpr retExpr; - if (childExpr->GetASTOp() == kASTMemberExpr || childExpr->GetASTOp() == kASTOpDeref) { - auto ireadFEExpr = static_cast(childFEIRExpr.get()); - stmt = std::make_unique(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(), - std::move(astUOPreDecExpr), ireadFEExpr->GetFieldID()); - retExpr = std::move(childFEIRExpr); - } else if (childExpr->GetASTOp() == kASTSubscriptExpr) { - auto ireadFEExpr = static_cast(childFEIRExpr.get()); - auto indexFEExpr = ireadFEExpr->GetExprIndexs().front()->Clone(); - MIRType *mirArrayType = ireadFEExpr->GetTypeArray().GenerateMIRTypeAuto(); - MIRType *elemType = static_cast(mirArrayType)->GetElemType(); - MIRType *ptrMIRElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType, PTY_ptr); - auto ptrFEArrayType = std::make_unique(*ptrMIRElemType); - auto arrayExpr = FEIRBuilder::CreateExprAddrofArray(ireadFEExpr->GetUniqueTypeArray()->Clone(), - ireadFEExpr->GetUniqueExprArray()->Clone(), - ireadFEExpr->GetArrayName(), - ireadFEExpr->GetExprIndexs()); - stmt = std::make_unique(std::move(ptrFEArrayType), - std::move(arrayExpr), - std::move(astUOPreDecExpr), 0); - retExpr = std::move(childFEIRExpr); - } else { - UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, - isGlobal, false); - UniqueFEIRVar selfMoveVar = selfVar->Clone(); - stmt = FEIRBuilder::CreateStmtDAssign(std::move(selfMoveVar), std::move(astUOPreDecExpr)); - retExpr = FEIRBuilder::CreateExprDRead(std::move(selfVar)); - } - stmts.emplace_back(std::move(stmt)); - return retExpr; + return ASTUOSideEffectExpr(OP_sub, stmts); } MIRConst *ASTUOAddrOfExpr::GenerateMIRConstImpl() const { @@ -707,7 +575,6 @@ UniqueFEIRExpr ASTUOAddrOfExpr::Emit2FEExprImpl(std::list &stmts } else { baseFEExpr = baseExpr->Emit2FEExpr(stmts); } - FieldID fieldID = 0; if (isArrow) { CHECK_FATAL(baseType->IsMIRPtrType(), "Must be ptr type!"); @@ -730,9 +597,14 @@ UniqueFEIRExpr ASTUOAddrOfExpr::Emit2FEExprImpl(std::list &stmts static_cast(addrOfExpr.get())->SetFieldID(fieldID); } } else if (astOp == kASTSubscriptExpr) { - ASTArraySubscriptExpr *arraySubExpr = static_cast(childExpr); - arraySubExpr->SetAddrOfFlag(true); - addrOfExpr = childExpr->Emit2FEExpr(stmts); + auto childFEExpr = childExpr->Emit2FEExpr(stmts); + auto iread = static_cast(childFEExpr.get()); + if (iread->GetFieldID() == 0) { + return iread->GetClonedOpnd(); + } else { + return std::make_unique(iread->GetClonedPtrType(), iread->GetFieldID(), + iread->GetClonedOpnd()); + } } else { // other potential expr should concern UniqueFEIRExpr childFEIRExpr; childFEIRExpr = childExpr->Emit2FEExpr(stmts); @@ -1295,41 +1167,49 @@ int32 ASTArraySubscriptExpr::TranslateArraySubscript2Offset() const { } UniqueFEIRExpr ASTArraySubscriptExpr::Emit2FEExprImpl(std::list &stmts) const { - std::list indexExprs; - UniqueFEIRExpr arrayStoreForCExpr; - UniqueFEIRType typeNative = FEIRTypeHelper::CreateTypeNative(*baseExpr->GetType()); - UniqueFEIRExpr baseFEExpr; - if (baseExpr->GetASTOp() == kASTStringLiteral) { - UniqueFEIRVar unamedVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("unamedstr_"), - *baseExpr->GetType(), true, false); - baseFEExpr = FEIRBuilder::CreateExprAddrofVar(std::move(unamedVar)); - FEIRExprAddrofVar *addrofVarExpr = static_cast(baseFEExpr.get()); - addrofVarExpr->SetVarValue(baseExpr->GenerateMIRConst()); - } else { - baseFEExpr = baseExpr->Emit2FEExpr(stmts); - } - for (auto expr : idxExprs) { - UniqueFEIRExpr feirExpr = expr->Emit2FEExpr(stmts); - indexExprs.emplace_front(std::move(feirExpr)); - } - if (memberExpr != nullptr) { - auto memExpr = static_cast(memberExpr)->Emit2FEExpr(stmts); - auto memType = FEIRTypeHelper::CreateTypeNative(*static_cast(memberExpr)->GetMemberType()); - CHECK_FATAL(memType, "memType should not be nullptr"); - arrayStoreForCExpr = FEIRBuilder::CreateExprArrayStoreForC(std::move(memExpr), indexExprs, std::move(memType), - std::move(baseFEExpr), std::move(typeNative), - baseExprVarName); + auto baseAddrFEExpr = baseExpr->Emit2FEExpr(stmts); + auto retFEType = std::make_unique(*mirType); + auto arrayFEType = std::make_unique(*arrayType); + auto mirPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mirType); + auto fePtrType = std::make_unique(*mirPtrType); + UniqueFEIRExpr addrOfArray; + if (arrayType->GetKind() == MIRTypeKind::kTypeArray) { + std::list feIdxExprs; + for (auto idxExpr : idxExprs) { + auto feIdxExpr = idxExpr->Emit2FEExpr(stmts); + feIdxExprs.push_front(std::move(feIdxExpr)); + } + addrOfArray = FEIRBuilder::CreateExprAddrofArray(arrayFEType->Clone(), std::move(baseAddrFEExpr), "", feIdxExprs); } else { - if (baseFEExpr->GetKind() == kExprCStyleCast) { - FEIRExprCStyleCast *expr = static_cast(baseFEExpr.get()); - baseFEExpr = expr->GetSubExpr()->Clone(); - typeNative = FEIRTypeHelper::CreateTypeNative(*expr->GetMIRType()); + std::vector offsetExprs; + UniqueFEIRExpr offsetExpr; + auto sizeType = std::make_unique(*GlobalTables::GetTypeTable().GetPrimType(PTY_u64)); + for (int i = 0; i < idxExprs.size(); i++) { + auto feIdxExpr = idxExprs[i]->Emit2FEExpr(stmts); + auto feSizeExpr = FEIRBuilder::CreateExprConstU64(baseExprTypes[i]->GetSize()); + if (feIdxExpr->GetPrimType() != PTY_i64) { + feIdxExpr = FEIRBuilder::CreateExprCvtPrim(std::move(feIdxExpr), PTY_i64); + } + auto feOffsetExpr = FEIRBuilder::CreateExprBinary(sizeType->Clone(), OP_mul, std::move(feIdxExpr), + std::move(feSizeExpr)); + offsetExprs.emplace_back(std::move(feOffsetExpr)); + } + if (offsetExprs.size() == 1) { + offsetExpr = std::move(offsetExprs[0]); + } else if (offsetExprs.size() >= 2) { + offsetExpr = FEIRBuilder::CreateExprBinary(sizeType->Clone(), OP_add, std::move(offsetExprs[0]), + std::move(offsetExprs[1])); + if (offsetExprs.size() >= 3) { + for (int i = 2; i < offsetExprs.size(); i++) { + offsetExpr = FEIRBuilder::CreateExprBinary(sizeType->Clone(), OP_add, std::move(offsetExpr), + std::move(offsetExprs[i])); + } + } } - arrayStoreForCExpr = FEIRBuilder::CreateExprArrayStoreForC(std::move(baseFEExpr), indexExprs, - std::move(typeNative), baseExprVarName); + addrOfArray = FEIRBuilder::CreateExprBinary(std::move(sizeType), OP_add, std::move(baseAddrFEExpr), + std::move(offsetExpr)); } - static_cast(arrayStoreForCExpr.get())->SetAddrOfFlag(isAddrOf); - return arrayStoreForCExpr; + return FEIRBuilder::CreateExprIRead(std::move(retFEType), fePtrType->Clone(), addrOfArray->Clone()); } UniqueFEIRExpr ASTExprUnaryExprOrTypeTraitExpr::Emit2FEExprImpl(std::list &stmts) const { @@ -1345,26 +1225,6 @@ ASTMemberExpr *ASTMemberExpr::findFinalMember(ASTMemberExpr *startExpr, std::lis return findFinalMember(static_cast(startExpr->baseExpr), memberNames); } -void ASTMemberExpr::Emit2FEExprImplForArrayElemIsStruct(UniqueFEIRExpr baseFEExpr, std::string &tmpStructName, - std::list &stmts) const { - if (baseExpr->GetASTOp() == kASTSubscriptExpr) { - auto arrayStoreForC = static_cast(baseFEExpr.get()); - FEIRExpr &exprArray = arrayStoreForC->GetExprArray(); - std::list &indexsExpr = arrayStoreForC->GetExprIndexs(); - UniqueFEIRType typeArray = arrayStoreForC->GetTypeArray().Clone(); - UniqueFEIRExpr uExprArray = exprArray.Clone(); - const std::string &arrayName = static_cast(baseExpr)->GetBaseExprVarName(); - UniqueFEIRExpr srcExpr = FEIRBuilder::CreateExprAddrofArray(std::move(typeArray), std::move(baseFEExpr), - arrayName, indexsExpr); - MIRType *ptrBaseType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*baseType, PTY_ptr); - tmpStructName = FEUtils::GetSequentialName("struct_tmpvar_"); - UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpStructName, *ptrBaseType); - auto uTmpVar = tmpVar->Clone(); - UniqueFEIRStmt readStmt1 = FEIRBuilder::CreateStmtDAssign(uTmpVar->Clone(), std::move(srcExpr)); - stmts.emplace_back(std::move(readStmt1)); - } -} - UniqueFEIRExpr ASTMemberExpr::Emit2FEExprImpl(std::list &stmts) const { UniqueFEIRExpr baseFEExpr; std::string fieldName = memberName; @@ -1381,7 +1241,6 @@ UniqueFEIRExpr ASTMemberExpr::Emit2FEExprImpl(std::list &stmts) fieldName = ASTUtil::Join(memberNameList, "."); } else { baseFEExpr = baseExpr->Emit2FEExpr(stmts); - Emit2FEExprImplForArrayElemIsStruct(baseFEExpr->Clone(), tmpStructName, stmts); } UniqueFEIRType baseFEType = std::make_unique(*baseType); if (isArrow) { @@ -1399,35 +1258,22 @@ UniqueFEIRExpr ASTMemberExpr::Emit2FEExprImpl(std::list &stmts) return FEIRBuilder::CreateExprIRead(std::move(retFEType), std::move(baseFEType), std::move(baseFEExpr), fieldID); } } else { - if (baseExpr->GetASTOp() != kASTSubscriptExpr) { - CHECK_FATAL(baseType->IsStructType(), "basetype must be StructType"); - MIRStructType *structType = static_cast(baseType); - FieldID fieldID = FEUtils::GetStructFieldID(structType, fieldName); - UniqueFEIRType memberFEType = std::make_unique(*memberType); - if (baseFEExpr->GetKind() == FEIRNodeKind::kExprIRead) { - static_cast(baseFEExpr.get())->SetFieldID(fieldID); - baseFEExpr->SetType(std::move(memberFEType)); - return baseFEExpr; - } - UniqueFEIRVar tmpVar = static_cast(baseFEExpr.get())->GetVar()->Clone(); - if (memberFEType->IsArray()) { - auto addrofExpr = std::make_unique(std::move(tmpVar)); - addrofExpr->SetFieldID(fieldID); - return addrofExpr; - } else { - return FEIRBuilder::CreateExprDReadAggField(std::move(tmpVar), fieldID, std::move(memberFEType)); - } - } else { // GetASTOp() is kASTSubscriptExpr - uint32 fieldID = 0; - GStrIdx fieldNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(memberName); - auto ptrMIRStructType = std::make_unique(*baseType); - MIRStructType* mirStructType = static_cast(ptrMIRStructType->GenerateMIRType()); - FEManager::GetMIRBuilder().TraverseToNamedField(*mirStructType, fieldNameIdx, fieldID); - auto fieldVar = FEIRBuilder::CreateVarNameForC(memberName, *memberType); - MIRType *ptrBaseType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*baseType, PTY_ptr); - UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpStructName, *ptrBaseType); - return FEIRBuilder::CreateExprFieldLoadForC(std::move(tmpVar), std::move(fieldVar), - mirStructType, fieldID); + CHECK_FATAL(baseType->IsStructType(), "basetype must be StructType"); + MIRStructType *structType = static_cast(baseType); + FieldID fieldID = FEUtils::GetStructFieldID(structType, fieldName); + UniqueFEIRType memberFEType = std::make_unique(*memberType); + if (baseFEExpr->GetKind() == FEIRNodeKind::kExprIRead) { + static_cast(baseFEExpr.get())->SetFieldID(fieldID); + baseFEExpr->SetType(std::move(memberFEType)); + return baseFEExpr; + } + UniqueFEIRVar tmpVar = static_cast(baseFEExpr.get())->GetVar()->Clone(); + if (memberFEType->IsArray()) { + auto addrofExpr = std::make_unique(std::move(tmpVar)); + addrofExpr->SetFieldID(fieldID); + return addrofExpr; + } else { + return FEIRBuilder::CreateExprDReadAggField(std::move(tmpVar), fieldID, std::move(memberFEType)); } } return nullptr; @@ -1530,40 +1376,15 @@ UniqueFEIRExpr ASTBinaryOperatorExpr::Emit2FEExprImpl(std::list } } -void ASTAssignExpr::ProcessAssign4ExprArrayStoreForC(std::list &stmts, UniqueFEIRExpr leftFEExpr, - UniqueFEIRExpr rightFEExpr) const { - auto arrayStoreForC = static_cast(leftFEExpr.get()); - FEIRExpr &exprArray = arrayStoreForC->GetExprArray(); - std::list &indexsExpr = arrayStoreForC->GetExprIndexs(); - FEIRType &typeArray = arrayStoreForC->GetTypeArray(); - UniqueFEIRExpr uExprArray = exprArray.Clone(); - UniqueFEIRType uTypeArray = typeArray.Clone(); - auto arrayName = arrayStoreForC->GetArrayName(); - if (arrayStoreForC->IsMember()) { - FEIRExpr &exprStruct = arrayStoreForC->GetExprStruct(); - FEIRType &typeStruct = arrayStoreForC->GetTypeSruct(); - UniqueFEIRExpr uExprStruct = exprStruct.Clone(); - UniqueFEIRType uTypeStruct = typeStruct.Clone(); - UniqueFEIRStmt stmt = std::make_unique(std::move(rightFEExpr), - std::move(uExprArray), - indexsExpr, - std::move(uTypeArray), - std::move(uExprStruct), - std::move(uTypeStruct), - arrayName); - stmts.emplace_back(std::move(stmt)); +UniqueFEIRExpr ASTAssignExpr::Emit2FEExprImpl(std::list &stmts) const { + UniqueFEIRExpr leftFEExpr; + if (isCompoundAssign) { + std::list dummyStmts; + leftFEExpr = leftExpr->Emit2FEExpr(dummyStmts); } else { - UniqueFEIRStmt stmt = std::make_unique(std::move(rightFEExpr), - std::move(uExprArray), - indexsExpr, - std::move(uTypeArray), - arrayName); - stmts.emplace_back(std::move(stmt)); + leftFEExpr = leftExpr->Emit2FEExpr(stmts); } -} - -UniqueFEIRExpr ASTAssignExpr::ProcessAssign(std::list &stmts, UniqueFEIRExpr leftFEExpr, - UniqueFEIRExpr rightFEExpr) const { + UniqueFEIRExpr rightFEExpr = rightExpr->Emit2FEExpr(stmts); // C89 does not support lvalue casting, but cxx support, needs to improve here if (leftFEExpr->GetKind() == FEIRNodeKind::kExprDRead && !leftFEExpr->GetType()->IsArray()) { auto dreadFEExpr = static_cast(leftFEExpr.get()); @@ -1579,34 +1400,10 @@ UniqueFEIRExpr ASTAssignExpr::ProcessAssign(std::list &stmts, Un std::move(rightFEExpr), fieldID); stmts.emplace_back(std::move(preStmt)); return leftFEExpr; - } else if (leftFEExpr->GetKind() == FEIRNodeKind::kExprArrayStoreForC) { - ProcessAssign4ExprArrayStoreForC(stmts, leftFEExpr->Clone(), rightFEExpr->Clone()); - return leftFEExpr; - } else if (leftFEExpr->GetKind() == FEIRNodeKind::kExprFieldLoadForC) { - auto exprFieldLoadForC = static_cast(leftFEExpr.get()); - UniqueFEIRVar varStruct = exprFieldLoadForC->GetStructVar().Clone(); - MIRStructType *structType = exprFieldLoadForC->GetMIRStructType(); - uint32 fieldID = exprFieldLoadForC->GetFieldID(); - UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtFieldStoreForC(std::move(varStruct), std::move(rightFEExpr), - structType, fieldID); - stmts.emplace_back(std::move(stmt)); - return leftFEExpr; } return nullptr; } -UniqueFEIRExpr ASTAssignExpr::Emit2FEExprImpl(std::list &stmts) const { - UniqueFEIRExpr leftFEExpr; - if (isCompoundAssign) { - std::list dummyStmts; - leftFEExpr = leftExpr->Emit2FEExpr(dummyStmts); - } else { - leftFEExpr = leftExpr->Emit2FEExpr(stmts); - } - UniqueFEIRExpr rightFEExpr = rightExpr->Emit2FEExpr(stmts); - return ProcessAssign(stmts, std::move(leftFEExpr), std::move(rightFEExpr)); -} - UniqueFEIRExpr ASTBOComma::Emit2FEExprImpl(std::list &stmts) const { auto leftFEExpr = leftExpr->Emit2FEExpr(stmts); std::list exprs; diff --git a/src/mplfe/ast_input/src/ast_function.cpp b/src/mplfe/ast_input/src/ast_function.cpp index d9c1b34e69..e227c2fc00 100644 --- a/src/mplfe/ast_input/src/ast_function.cpp +++ b/src/mplfe/ast_input/src/ast_function.cpp @@ -67,6 +67,8 @@ void ASTFunction::SetMIRFunctionInfo() { bool ASTFunction::ProcessImpl() { FE_INFO_LEVEL(FEOptions::kDumpLevelInfoDetail, "ASTFunction::Process() for %s", astFunc.GetName().c_str()); bool success = true; + mirFunction.NewBody(); + FEManager::GetMIRBuilder().SetCurrentFunction(mirFunction); SetMIRFunctionInfo(); success = success && GenerateArgVarList("gen arg var list"); success = success && EmitToFEIRStmt("emit to feir"); @@ -85,8 +87,6 @@ void ASTFunction::FinishImpl() { bool ASTFunction::EmitToMIR(const std::string &phaseName) { phaseResult.RegisterPhaseNameAndStart(phaseName); - mirFunction.NewBody(); - FEManager::GetMIRBuilder().SetCurrentFunction(mirFunction); EmitToMIRStmt(); return phaseResult.Finish(); } diff --git a/src/mplfe/ast_input/src/ast_parser.cpp b/src/mplfe/ast_input/src/ast_parser.cpp index b52cedff64..5cf01aa1d6 100644 --- a/src/mplfe/ast_input/src/ast_parser.cpp +++ b/src/mplfe/ast_input/src/ast_parser.cpp @@ -520,6 +520,13 @@ ASTStmt *ASTParser::ProcessStmtDeclStmt(MapleAllocator &allocator, const clang:: const clang::Decl *decl = declStmt.getSingleDecl(); if (decl != nullptr) { ASTDecl *ad = ProcessDecl(allocator, *decl); + if (decl->getKind() == clang::Decl::Var) { + const clang::VarDecl *varDecl = llvm::cast(decl); + ASTExpr *expr = ProcessExprInType(allocator, varDecl->getType()); + if (expr != nullptr) { + astStmt->SetASTExpr(expr); + } + } if (ad != nullptr) { astStmt->SetSubDecl(ad); } @@ -530,6 +537,13 @@ ASTStmt *ASTParser::ProcessStmtDeclStmt(MapleAllocator &allocator, const clang:: clang::DeclGroupRef::const_iterator it; for (it = declGroupRef.begin(); it != declGroupRef.end(); ++it) { ASTDecl *ad = ProcessDecl(allocator, **it); + if ((*it)->getKind() == clang::Decl::Var) { + const clang::VarDecl *varDecl = llvm::cast(*it); + ASTExpr *expr = ProcessExprInType(allocator, varDecl->getType()); + if (expr != nullptr) { + astStmt->SetASTExpr(expr); + } + } if (ad != nullptr) { astStmt->SetSubDecl(ad); } @@ -684,6 +698,15 @@ ASTExpr *ASTParser::ProcessExpr(MapleAllocator &allocator, const clang::Expr *ex } } +ASTExpr *ASTParser::ProcessExprInType(MapleAllocator &allocator, const clang::QualType &qualType) { + const clang::Type *type = qualType.getCanonicalType().getTypePtr(); + if (type->isVariableArrayType()) { + const clang::VariableArrayType *vAType = llvm::cast(type); + return ProcessExpr(allocator, vAType->getSizeExpr()); + } + return nullptr; +} + ASTUnaryOperatorExpr *ASTParser::AllocUnaryOperatorExpr(MapleAllocator &allocator, const clang::UnaryOperator &expr) { clang::UnaryOperator::Opcode clangOpCode = expr.getOpcode(); switch (clangOpCode) { @@ -742,6 +765,24 @@ const clang::Expr *ASTParser::PeelParen(const clang::Expr &expr) { return exprPtr; } +const clang::Expr *ASTParser::PeelParen2(const clang::Expr &expr) { + const clang::Expr *exprPtr = &expr; + while (llvm::isa(exprPtr) || + (llvm::isa(exprPtr) && + llvm::cast(exprPtr)->getOpcode() == clang::UO_Extension) || + (llvm::isa(exprPtr) && + (llvm::cast(exprPtr)->getCastKind() == clang::CK_BitCast))) { + if (llvm::isa(exprPtr)) { + exprPtr = llvm::cast(exprPtr)->getSubExpr(); + } else if (llvm::isa(exprPtr)) { + exprPtr = llvm::cast(exprPtr)->getSubExpr(); + } else { + exprPtr = llvm::cast(exprPtr)->getSubExpr(); + } + } + return exprPtr; +} + ASTExpr *ASTParser::ProcessExprUnaryOperator(MapleAllocator &allocator, const clang::UnaryOperator &uo) { ASTUnaryOperatorExpr *astUOExpr = AllocUnaryOperatorExpr(allocator, uo); CHECK_FATAL(astUOExpr != nullptr, "astUOExpr is nullptr"); @@ -990,10 +1031,11 @@ ASTExpr *ASTParser::ProcessExprStringLiteral(MapleAllocator &allocator, const cl ASTExpr *ASTParser::ProcessExprArraySubscriptExpr(MapleAllocator &allocator, const clang::ArraySubscriptExpr &expr) { auto *astArraySubscriptExpr = ASTDeclsBuilder::ASTExprBuilder(allocator); CHECK_FATAL(astArraySubscriptExpr != nullptr, "astArraySubscriptExpr is nullptr"); - clang::ArraySubscriptExpr *exprTmp = const_cast(&expr); + auto *exprTmp = const_cast(&expr); auto base = exprTmp->getBase(); while (exprTmp != nullptr && exprTmp->getStmtClass() == clang::Stmt::ArraySubscriptExprClass) { base = exprTmp->getBase(); + base = const_cast(PeelParen2(*base)); MIRType *baseExprType = astFile->CvtType(exprTmp->getType()); astArraySubscriptExpr->SetBaseExprType(baseExprType); ASTExpr *idxExpr = ProcessExpr(allocator, exprTmp->getIdx()); @@ -1004,34 +1046,25 @@ ASTExpr *ASTParser::ProcessExprArraySubscriptExpr(MapleAllocator &allocator, con if (base->getStmtClass() != clang::Stmt::ImplicitCastExprClass) { break; } - base = static_cast(base)->getSubExpr(); - if (base->getStmtClass() != clang::Stmt::ArraySubscriptExprClass) { + if (PeelParen2(*static_cast(base)->getSubExpr())->getStmtClass() != + clang::Stmt::ArraySubscriptExprClass) { break; } + base = const_cast(PeelParen2(*static_cast(base)->getSubExpr())); exprTmp = static_cast(base); } - // array in struct - if (base->getStmtClass() == clang::Stmt::MemberExprClass) { - ASTExpr *memberExpr = ProcessExpr(allocator, base); - ASTExpr *declRefExpr = static_cast(memberExpr)->GetBaseExpr(); - if (declRefExpr == nullptr) { - return nullptr; - } - astArraySubscriptExpr->SetBaseExpr(declRefExpr); - astArraySubscriptExpr->SetMemberExpr(*memberExpr); - astArraySubscriptExpr->SetBaseExprVarName(declRefExpr->GetASTDecl()->GenerateUniqueVarName()); + if (base->getStmtClass() == clang::Stmt::ImplicitCastExprClass && + !static_cast(base)->isPartOfExplicitCast()) { + auto arrayMirType = astFile->CvtType( + static_cast(base)->getSubExpr()->getType().getCanonicalType()); + astArraySubscriptExpr->SetArrayType(arrayMirType); } else { - // base is DeclRefExpr - ASTExpr *baseExpr = ProcessExpr(allocator, base); - if (baseExpr == nullptr) { - return nullptr; - } - astArraySubscriptExpr->SetBaseExpr(baseExpr); - ASTDecl *decl = baseExpr->GetASTDecl(); - if (decl != nullptr) { - astArraySubscriptExpr->SetBaseExprVarName(decl->GenerateUniqueVarName()); - } + astArraySubscriptExpr->SetArrayType(astFile->CvtType(base->getType().getCanonicalType())); } + ASTExpr *astBaseExpr = ProcessExpr(allocator, base); + astArraySubscriptExpr->SetBaseExpr(astBaseExpr); + auto *mirType = astFile->CvtType(expr.getType().getCanonicalType()); + astArraySubscriptExpr->SetType(mirType); return astArraySubscriptExpr; } @@ -1300,7 +1333,9 @@ ASTExpr *ASTParser::ProcessExprCallExpr(MapleAllocator &allocator, const clang:: } if (builtingFuncPtrMap.find(funcName) != builtingFuncPtrMap.end()) { - std::stringstream ss; + static std::stringstream ss; + ss.clear(); + ss.str(std::string()); ss << funcName; ASTExpr *builtinFuncExpr = ParseBuiltinFunc(allocator, expr, ss); if (builtinFuncExpr != nullptr) { @@ -1818,8 +1853,8 @@ bool ASTParser::PreProcessAST() { ASTDecl *astDecl = ProcessDecl##CLASS##Decl(allocator, llvm::cast(decl)); \ if (astDecl != nullptr) { \ astDecl->SetDeclPos(astFile->GetDeclPosInfo(decl)); \ - astDecl->SetGlobal(decl.isDefinedOutsideFunctionOrMethod()); \ astDecl->SetAlign(astFile->GetMaxAlign(decl)); \ + astDecl->SetGlobal(decl.isDefinedOutsideFunctionOrMethod()); \ } \ return astDecl; \ } @@ -1926,8 +1961,15 @@ ASTDecl *ASTParser::ProcessDeclFunctionDecl(MapleAllocator &allocator, const cla std::vector parmNamesIn; typeDescIn.push_back(retType); unsigned int numParam = funcDecl.getNumParams(); + std::list implicitStmts; for (uint32_t i = 0; i < numParam; ++i) { const clang::ParmVarDecl *parmDecl = funcDecl.getParamDecl(i); + ASTExpr *expr = ProcessExprInType(allocator, parmDecl->getOriginalType()); + if (expr != nullptr) { + ASTStmtDummy *stmt = ASTDeclsBuilder::ASTStmtBuilder(allocator); + stmt->SetASTExpr(expr); + implicitStmts.emplace_back(stmt); + } ASTDecl *parmVarDecl = ProcessDecl(allocator, *parmDecl); parmNamesIn.emplace_back(parmVarDecl->GetName()); typeDescIn.push_back(parmVarDecl->GetTypeDesc().front()); @@ -1941,6 +1983,7 @@ ASTDecl *ASTParser::ProcessDeclFunctionDecl(MapleAllocator &allocator, const cla ASTStmt *astCompoundStmt = ProcessStmt(allocator, *llvm::cast(funcDecl.getBody())); if (astCompoundStmt != nullptr) { astFunc->SetCompoundStmt(astCompoundStmt); + astFunc->InsertStmtsIntoCompoundStmtAtFront(implicitStmts); } else { return nullptr; } diff --git a/src/mplfe/ast_input/src/ast_parser_builting_func.cpp b/src/mplfe/ast_input/src/ast_parser_builting_func.cpp index 8e0b35559a..fa3926cd02 100644 --- a/src/mplfe/ast_input/src/ast_parser_builting_func.cpp +++ b/src/mplfe/ast_input/src/ast_parser_builting_func.cpp @@ -56,9 +56,9 @@ UniqueFEIRExpr ASTCallExpr::EmitBuiltinCtz(std::list &stmts) con #else if (mirType->GetSize() == 4) { // 32 bit - return std::make_unique(std::move(feTy), INTRN_C_ctz32, argOpnds); + return std::make_unique(std::move(feTy), INTRN_C_ctz32, argOpnds); } - return std::make_unique(std::move(feTy), INTRN_C_ctz32, argOpnds); + return std::make_unique(std::move(feTy), INTRN_C_ctz32, argOpnds); #endif } @@ -74,9 +74,9 @@ UniqueFEIRExpr ASTCallExpr::EmitBuiltinClz(std::list &stmts) con #else if (mirType->GetSize() == 4) { // 32 bit - return std::make_unique(std::move(feTy), INTRN_C_clz32, argOpnds); + return std::make_unique(std::move(feTy), INTRN_C_clz32, argOpnds); } - return std::make_unique(std::move(feTy), INTRN_C_clz64, argOpnds); + return std::make_unique(std::move(feTy), INTRN_C_clz64, argOpnds); #endif } diff --git a/src/mplfe/ast_input/src/ast_stmt.cpp b/src/mplfe/ast_input/src/ast_stmt.cpp index 385742f7ef..33fcae486d 100644 --- a/src/mplfe/ast_input/src/ast_stmt.cpp +++ b/src/mplfe/ast_input/src/ast_stmt.cpp @@ -28,10 +28,24 @@ void ASTStmt::SetASTExpr(ASTExpr *astExpr) { exprs.emplace_back(astExpr); } +// ---------- ASTStmtDummy ---------- +std::list ASTStmtDummy::Emit2FEStmtImpl() const { + std::list stmts; + for (auto expr : exprs) { + (void)expr->Emit2FEExpr(stmts); + } + return stmts; +} + +// ---------- ASTCompoundStmt ---------- void ASTCompoundStmt::SetASTStmt(ASTStmt *astStmt) { astStmts.emplace_back(astStmt); } +void ASTCompoundStmt::InsertASTStmtsAtFront(const std::list &stmts) { + astStmts.insert(astStmts.begin(), stmts.begin(), stmts.end()); +} + const std::list &ASTCompoundStmt::GetASTStmtList() const { return astStmts; } @@ -267,6 +281,9 @@ std::list ASTNullStmt::Emit2FEStmtImpl() const { // ---------- ASTDeclStmt ---------- std::list ASTDeclStmt::Emit2FEStmtImpl() const { std::list stmts; + for (auto expr : exprs) { + (void)expr->Emit2FEExpr(stmts); + } for (auto decl : subDecls) { decl->GenerateInitStmt(stmts); } @@ -282,6 +299,7 @@ std::map ASTCallExprStmt::Init ans["__builtin_va_start"] = &ASTCallExprStmt::ProcessBuiltinVaStart; ans["__builtin_va_end"] = &ASTCallExprStmt::ProcessBuiltinVaEnd; ans["__builtin_va_copy"] = &ASTCallExprStmt::ProcessBuiltinVaCopy; + ans["__builtin_prefetch"] = &ASTCallExprStmt::ProcessBuiltinPrefetch; return ans; } @@ -427,6 +445,11 @@ std::list ASTCallExprStmt::ProcessBuiltinVaCopy() const { return stmts; } +std::list ASTCallExprStmt::ProcessBuiltinPrefetch() const { + std::list stmts; + return stmts; +} + // ---------- ASTImplicitCastExprStmt ---------- std::list ASTImplicitCastExprStmt::Emit2FEStmtImpl() const { CHECK_FATAL(exprs.size() == 1, "Only one sub expr supported!"); diff --git a/src/mplfe/common/include/feir_stmt.h b/src/mplfe/common/include/feir_stmt.h index 3c7230bf57..a763e22d96 100644 --- a/src/mplfe/common/include/feir_stmt.h +++ b/src/mplfe/common/include/feir_stmt.h @@ -939,6 +939,20 @@ class FEIRExprIntrinsicop : public FEIRExprNary { uint32 typeID = UINT32_MAX; }; // class FEIRExprIntrinsicop +class FEIRExprIntrinsicopForC : public FEIRExprNary { + public: + FEIRExprIntrinsicopForC(std::unique_ptr exprType, MIRIntrinsicID argIntrinsicID, + const std::vector> &argOpnds); + ~FEIRExprIntrinsicopForC() = default; + + protected: + std::unique_ptr CloneImpl() const override; + BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; + + private: + MIRIntrinsicID intrinsicID; +}; // class FEIRExprIntrinsicopForC + class FEIRExprJavaMerge : public FEIRExprNary { public: FEIRExprJavaMerge(std::unique_ptr mergedTypeArg, const std::vector> &argOpnds); @@ -1107,6 +1121,10 @@ class FEIRExprArrayStoreForC : public FEIRExpr { fieldType = std::move(argFieldType); } + std::vector GetVarUsesImpl() const override { + return exprArray->GetVarUses(); + } + private: UniqueFEIRExpr exprArray; mutable std::list exprIndexs; diff --git a/src/mplfe/common/src/feir_builder.cpp b/src/mplfe/common/src/feir_builder.cpp index d2e836647d..24dd046a5d 100644 --- a/src/mplfe/common/src/feir_builder.cpp +++ b/src/mplfe/common/src/feir_builder.cpp @@ -615,18 +615,13 @@ UniqueFEIRStmt FEIRBuilder::AssginStmtField(UniqueFEIRExpr addrExpr, UniqueFEIRE UniqueFEIRStmt stmt; FieldID baseID = addrExpr->GetFieldID(); UniqueFEIRType addrType = addrExpr->GetType()->Clone(); - UniqueFEIRType ptrType = FEIRTypeHelper::CreateTypeNative( - *GlobalTables::GetTypeTable().GetOrCreatePointerType(*addrType->GenerateMIRTypeAuto(), PTY_ptr)); if (addrExpr->GetKind() == kExprDRead) { stmt = CreateStmtDAssignAggField( static_cast(addrExpr.get())->GetVar()->Clone(), std::move(srcExpr), baseID + fieldID); - } else if (addrExpr->GetKind() == kExprArrayStoreForC) { - auto arrayExpr = static_cast(addrExpr.get()); - arrayExpr->SetAddrOfFlag(true); // retrun addr - stmt = CreateStmtIAssign(std::move(ptrType), std::move(addrExpr), std::move(srcExpr), baseID + fieldID); } else if (addrExpr->GetKind() == kExprIRead) { auto ireadExpr = static_cast(addrExpr.get()); - stmt = CreateStmtIAssign(std::move(ptrType), ireadExpr->GetClonedOpnd(), std::move(srcExpr), baseID + fieldID); + stmt = CreateStmtIAssign(ireadExpr->GetClonedPtrType(), ireadExpr->GetClonedOpnd(), + std::move(srcExpr), baseID + fieldID); } else { CHECK_FATAL(false, "unsupported expr in AssginStmtField"); } diff --git a/src/mplfe/common/src/feir_stmt.cpp b/src/mplfe/common/src/feir_stmt.cpp index 4566322b29..27a742f929 100644 --- a/src/mplfe/common/src/feir_stmt.cpp +++ b/src/mplfe/common/src/feir_stmt.cpp @@ -1245,7 +1245,7 @@ std::list FEIRStmtArrayStore::GenMIRStmtsImpl(MIRBuilder &mirBuilder) MIRType *ptrMIRElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mIRElemType, PTY_ptr); stmt = mirBuilder.CreateStmtIassign(*ptrMIRElemType, 0, arrayExpr, elemBn); } else { - reinterpret_cast(arrayExpr)->SetBoundsCheck(false); + reinterpret_cast(arrayExpr)->SetBoundsCheck(false); stmt = mirBuilder.CreateStmtIassign(*mIRElemType, 0, arrayExpr, elemBn); } return std::list({ stmt }); @@ -2454,14 +2454,19 @@ std::unique_ptr FEIRExprAddrofArray::CloneImpl() const { BaseNode *FEIRExprAddrofArray::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { MIRType *ptrMIRArrayType = typeNativeArray->GenerateMIRType(false); - std::unique_ptr tmpVar = std::make_unique(arrayName, typeNativeArray->Clone()); - std::vector nds; - MIRSymbol *mirSymbol = tmpVar->GenerateLocalMIRSymbol(mirBuilder); BaseNode *nodeAddrof = nullptr; - if (ptrMIRArrayType->GetKind() == kTypeArray) { - nodeAddrof = mirBuilder.CreateExprAddrof(0, *mirSymbol); + std::vector nds; + if (!arrayName.empty()) { + std::unique_ptr arrayVar = exprArray->GetVarUses().front()->Clone(); + MIRSymbol *mirSymbol = arrayVar->GenerateMIRSymbol(mirBuilder); + if (ptrMIRArrayType->GetKind() == kTypeArray) { + mirSymbol->SetTyIdx(ptrMIRArrayType->GetTypeIndex()); + nodeAddrof = mirBuilder.CreateExprAddrof(0, *mirSymbol); + } else { + nodeAddrof = mirBuilder.CreateDread(*mirSymbol, PTY_ptr); + } } else { - nodeAddrof = mirBuilder.CreateDread(*mirSymbol, PTY_ptr); + nodeAddrof = exprArray->GenMIRNode(mirBuilder); } nds.push_back(nodeAddrof); for (auto &e : exprIndexs) { @@ -3211,6 +3216,30 @@ bool FEIRExprIntrinsicop::IsAddrofImpl() const { return false; } +// ---------- FEIRExprIntrinsicopForC ---------- +FEIRExprIntrinsicopForC::FEIRExprIntrinsicopForC(std::unique_ptr exprType, MIRIntrinsicID argIntrinsicID, + const std::vector> &argOpnds) + : FEIRExprNary(OP_intrinsicop), + intrinsicID(argIntrinsicID) { + kind = FEIRNodeKind::kExprIntrinsicop; + SetType(std::move(exprType)); + AddOpnds(argOpnds); +} + +std::unique_ptr FEIRExprIntrinsicopForC::CloneImpl() const { + return std::make_unique(type->Clone(), intrinsicID, opnds); +} + +BaseNode *FEIRExprIntrinsicopForC::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { + MapleVector args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter()); + for (const auto &e : opnds) { + BaseNode *node = e->GenMIRNode(mirBuilder); + args.emplace_back(node); + } + return mirBuilder.CreateExprIntrinsicop(intrinsicID, op, + *type->GenerateMIRTypeAuto(), MapleVector(args)); +} + // ---------- FEIRExprJavaMerge ---------------- FEIRExprJavaMerge::FEIRExprJavaMerge(std::unique_ptr mergedTypeArg, const std::vector> &argOpnds) @@ -3581,27 +3610,7 @@ BaseNode *FEIRExprCStyleCast::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { auto *arrayType = static_cast(srcType); ASSERT(arrayType != nullptr, "ERROR:null pointer!"); ArrayNode *arrayNode = mirBuilder.CreateExprArray(*arrayType); - GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(refName); - MIRSymbol *var = nullptr; - if (strIdx != 0u) { - // try to find the decl in local scope first - MIRFunction *currentFunctionInner = mirBuilder.GetCurrentFunction(); -#ifndef USE_OPS - if (currentFunctionInner != nullptr) { - var = SymbolBuilder::Instance().GetSymbolFromStrIdx(strIdx, currentFunctionInner); - } - if (var == nullptr) { - var = SymbolBuilder::Instance().GetSymbolFromStrIdx(strIdx); - } -#else - if (currentFunctionInner != nullptr) { - var = mirBuilder.GetOrCreateLocalDecl(refName.c_str(), *arrayType); - } - if (var == nullptr) { - var = mirBuilder.GetOrCreateGlobalDecl(refName.c_str(), *arrayType); - } -#endif - } + MIRSymbol *var = subExpr->GetVarUses().front()->GenerateMIRSymbol(mirBuilder); arrayNode->GetNopnd().push_back(mirBuilder.CreateExprAddrof(0, *var)); for (uint8 i = 0; i < arrayType->GetDim(); ++i) { arrayNode->GetNopnd().push_back(mirBuilder.CreateIntConst(0, PTY_i32)); -- Gitee