THU-DSP-LAB
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
2
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity
llvm-project/llvm/lib/Target/CSKY/MCTargetDesc/CSKYELFStreamer.cpp

336 lines
10 KiB
C++
Raw Permalink Blame History

//===-- CSKYELFStreamer.cpp - CSKY ELF Target Streamer Methods ------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file provides CSKY specific target streamer methods.
//
//===----------------------------------------------------------------------===//
#include "CSKYELFStreamer.h"
#include "CSKYMCTargetDesc.h"
#include "MCTargetDesc/CSKYAsmBackend.h"
#include "MCTargetDesc/CSKYBaseInfo.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/MC/MCSymbolELF.h"
#include "llvm/Support/CSKYAttributes.h"
#include "llvm/Support/CSKYTargetParser.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/LEB128.h"
using namespace llvm;
// This part is for ELF object output.
CSKYTargetELFStreamer::CSKYTargetELFStreamer(MCStreamer &S,
const MCSubtargetInfo &STI)
: CSKYTargetStreamer(S), CurrentVendor("csky") {
MCAssembler &MCA = getStreamer().getAssembler();
const FeatureBitset &Features = STI.getFeatureBits();
unsigned EFlags = MCA.getELFHeaderEFlags();
EFlags |= ELF::EF_CSKY_ABIV2;
if (Features[CSKY::ProcCK801])
EFlags |= ELF::EF_CSKY_801;
else if (Features[CSKY::ProcCK802])
EFlags |= ELF::EF_CSKY_802;
else if (Features[CSKY::ProcCK803])
EFlags |= ELF::EF_CSKY_803;
else if (Features[CSKY::ProcCK804])
EFlags |= ELF::EF_CSKY_803;
else if (Features[CSKY::ProcCK805])
EFlags |= ELF::EF_CSKY_805;
else if (Features[CSKY::ProcCK807])
EFlags |= ELF::EF_CSKY_807;
else if (Features[CSKY::ProcCK810])
EFlags |= ELF::EF_CSKY_810;
else if (Features[CSKY::ProcCK860])
EFlags |= ELF::EF_CSKY_860;
else
EFlags |= ELF::EF_CSKY_810;
if (Features[CSKY::FeatureFPUV2_SF] || Features[CSKY::FeatureFPUV3_SF])
EFlags |= ELF::EF_CSKY_FLOAT;
EFlags |= ELF::EF_CSKY_EFV1;
MCA.setELFHeaderEFlags(EFlags);
}
MCELFStreamer &CSKYTargetELFStreamer::getStreamer() {
return static_cast<MCELFStreamer &>(Streamer);
}
void CSKYTargetELFStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
setAttributeItem(Attribute, Value, /*OverwriteExisting=*/true);
}
void CSKYTargetELFStreamer::emitTextAttribute(unsigned Attribute,
StringRef String) {
setAttributeItem(Attribute, String, /*OverwriteExisting=*/true);
}
void CSKYTargetELFStreamer::finishAttributeSection() {
if (Contents.empty())
return;
if (AttributeSection) {
Streamer.switchSection(AttributeSection);
} else {
MCAssembler &MCA = getStreamer().getAssembler();
AttributeSection = MCA.getContext().getELFSection(
".csky.attributes", ELF::SHT_CSKY_ATTRIBUTES, 0);
Streamer.switchSection(AttributeSection);
Streamer.emitInt8(ELFAttrs::Format_Version);
}
// Vendor size + Vendor name + '\0'
const size_t VendorHeaderSize = 4 + CurrentVendor.size() + 1;
// Tag + Tag Size
const size_t TagHeaderSize = 1 + 4;
const size_t ContentsSize = calculateContentSize();
Streamer.emitInt32(VendorHeaderSize + TagHeaderSize + ContentsSize);
Streamer.emitBytes(CurrentVendor);
Streamer.emitInt8(0); // '\0'
Streamer.emitInt8(ELFAttrs::File);
Streamer.emitInt32(TagHeaderSize + ContentsSize);
// Size should have been accounted for already, now
// emit each field as its type (ULEB or String).
for (AttributeItem item : Contents) {
Streamer.emitULEB128IntValue(item.Tag);
switch (item.Type) {
default:
llvm_unreachable("Invalid attribute type");
case AttributeType::Numeric:
Streamer.emitULEB128IntValue(item.IntValue);
break;
case AttributeType::Text:
Streamer.emitBytes(item.StringValue);
Streamer.emitInt8(0); // '\0'
break;
case AttributeType::NumericAndText:
Streamer.emitULEB128IntValue(item.IntValue);
Streamer.emitBytes(item.StringValue);
Streamer.emitInt8(0); // '\0'
break;
}
}
Contents.clear();
}
size_t CSKYTargetELFStreamer::calculateContentSize() const {
size_t Result = 0;
for (AttributeItem item : Contents) {
switch (item.Type) {
case AttributeType::Hidden:
break;
case AttributeType::Numeric:
Result += getULEB128Size(item.Tag);
Result += getULEB128Size(item.IntValue);
break;
case AttributeType::Text:
Result += getULEB128Size(item.Tag);
Result += item.StringValue.size() + 1; // string + '\0'
break;
case AttributeType::NumericAndText:
Result += getULEB128Size(item.Tag);
Result += getULEB128Size(item.IntValue);
Result += item.StringValue.size() + 1; // string + '\0';
break;
}
}
return Result;
}
void CSKYELFStreamer::EmitMappingSymbol(StringRef Name) {
if (Name == "$d" && State == EMS_Data)
return;
if (Name == "$t" && State == EMS_Text)
return;
if (Name == "$t" && State == EMS_None) {
State = EMS_Text;
return;
}
State = (Name == "$t" ? EMS_Text : EMS_Data);
auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
Name + "." + Twine(MappingSymbolCounter++)));
emitLabel(Symbol);
Symbol->setType(ELF::STT_NOTYPE);
Symbol->setBinding(ELF::STB_LOCAL);
}
void CSKYTargetELFStreamer::emitTargetAttributes(const MCSubtargetInfo &STI) {
StringRef CPU = STI.getCPU();
CSKY::ArchKind ArchID = CSKY::parseCPUArch(CPU);
if (ArchID == CSKY::ArchKind::CK804)
ArchID = CSKY::ArchKind::CK803;
StringRef CPU_ARCH = CSKY::getArchName(ArchID);
if (ArchID == CSKY::ArchKind::INVALID) {
CPU = "ck810";
CPU_ARCH = "ck810";
}
emitTextAttribute(CSKYAttrs::CSKY_ARCH_NAME, CPU_ARCH);
emitTextAttribute(CSKYAttrs::CSKY_CPU_NAME, CPU);
unsigned ISAFlag = 0;
if (STI.hasFeature(CSKY::HasE1))
ISAFlag |= CSKYAttrs::V2_ISA_E1;
if (STI.hasFeature(CSKY::HasE2))
ISAFlag |= CSKYAttrs::V2_ISA_1E2;
if (STI.hasFeature(CSKY::Has2E3))
ISAFlag |= CSKYAttrs::V2_ISA_2E3;
if (STI.hasFeature(CSKY::HasMP))
ISAFlag |= CSKYAttrs::ISA_MP;
if (STI.hasFeature(CSKY::Has3E3r1))
ISAFlag |= CSKYAttrs::V2_ISA_3E3R1;
if (STI.hasFeature(CSKY::Has3r1E3r2))
ISAFlag |= CSKYAttrs::V2_ISA_3E3R2;
if (STI.hasFeature(CSKY::Has3r2E3r3))
ISAFlag |= CSKYAttrs::V2_ISA_3E3R3;
if (STI.hasFeature(CSKY::Has3E7))
ISAFlag |= CSKYAttrs::V2_ISA_3E7;
if (STI.hasFeature(CSKY::HasMP1E2))
ISAFlag |= CSKYAttrs::ISA_MP_1E2;
if (STI.hasFeature(CSKY::Has7E10))
ISAFlag |= CSKYAttrs::V2_ISA_7E10;
if (STI.hasFeature(CSKY::Has10E60))
ISAFlag |= CSKYAttrs::V2_ISA_10E60;
if (STI.hasFeature(CSKY::FeatureTrust))
ISAFlag |= CSKYAttrs::ISA_TRUST;
if (STI.hasFeature(CSKY::FeatureJAVA))
ISAFlag |= CSKYAttrs::ISA_JAVA;
if (STI.hasFeature(CSKY::FeatureCache))
ISAFlag |= CSKYAttrs::ISA_CACHE;
if (STI.hasFeature(CSKY::FeatureNVIC))
ISAFlag |= CSKYAttrs::ISA_NVIC;
if (STI.hasFeature(CSKY::FeatureDSP))
ISAFlag |= CSKYAttrs::ISA_DSP;
if (STI.hasFeature(CSKY::HasDSP1E2))
ISAFlag |= CSKYAttrs::ISA_DSP_1E2;
if (STI.hasFeature(CSKY::HasDSPE60))
ISAFlag |= CSKYAttrs::V2_ISA_DSPE60;
if (STI.hasFeature(CSKY::FeatureDSPV2))
ISAFlag |= CSKYAttrs::ISA_DSP_ENHANCE;
if (STI.hasFeature(CSKY::FeatureDSP_Silan))
ISAFlag |= CSKYAttrs::ISA_DSP_SILAN;
if (STI.hasFeature(CSKY::FeatureVDSPV1_128))
ISAFlag |= CSKYAttrs::ISA_VDSP;
if (STI.hasFeature(CSKY::FeatureVDSPV2))
ISAFlag |= CSKYAttrs::ISA_VDSP_2;
if (STI.hasFeature(CSKY::HasVDSP2E3))
ISAFlag |= CSKYAttrs::ISA_VDSP_2E3;
if (STI.hasFeature(CSKY::HasVDSP2E60F))
ISAFlag |= CSKYAttrs::ISA_VDSP_2E60F;
emitAttribute(CSKYAttrs::CSKY_ISA_FLAGS, ISAFlag);
unsigned ISAExtFlag = 0;
if (STI.hasFeature(CSKY::HasFLOATE1))
ISAExtFlag |= CSKYAttrs::ISA_FLOAT_E1;
if (STI.hasFeature(CSKY::HasFLOAT1E2))
ISAExtFlag |= CSKYAttrs::ISA_FLOAT_1E2;
if (STI.hasFeature(CSKY::HasFLOAT1E3))
ISAExtFlag |= CSKYAttrs::ISA_FLOAT_1E3;
if (STI.hasFeature(CSKY::HasFLOAT3E4))
ISAExtFlag |= CSKYAttrs::ISA_FLOAT_3E4;
if (STI.hasFeature(CSKY::HasFLOAT7E60))
ISAExtFlag |= CSKYAttrs::ISA_FLOAT_7E60;
emitAttribute(CSKYAttrs::CSKY_ISA_EXT_FLAGS, ISAExtFlag);
if (STI.hasFeature(CSKY::FeatureDSP))
emitAttribute(CSKYAttrs::CSKY_DSP_VERSION,
CSKYAttrs::DSP_VERSION_EXTENSION);
if (STI.hasFeature(CSKY::FeatureDSPV2))
emitAttribute(CSKYAttrs::CSKY_DSP_VERSION, CSKYAttrs::DSP_VERSION_2);
if (STI.hasFeature(CSKY::FeatureVDSPV2))
emitAttribute(CSKYAttrs::CSKY_VDSP_VERSION, CSKYAttrs::VDSP_VERSION_2);
if (STI.hasFeature(CSKY::FeatureFPUV2_SF) ||
STI.hasFeature(CSKY::FeatureFPUV2_DF))
emitAttribute(CSKYAttrs::CSKY_FPU_VERSION, CSKYAttrs::FPU_VERSION_2);
else if (STI.hasFeature(CSKY::FeatureFPUV3_HF) ||
STI.hasFeature(CSKY::FeatureFPUV3_SF) ||
STI.hasFeature(CSKY::FeatureFPUV3_DF))
emitAttribute(CSKYAttrs::CSKY_FPU_VERSION, CSKYAttrs::FPU_VERSION_3);
bool hasAnyFloatExt = STI.hasFeature(CSKY::FeatureFPUV2_SF) ||
STI.hasFeature(CSKY::FeatureFPUV2_DF) ||
STI.hasFeature(CSKY::FeatureFPUV3_HF) ||
STI.hasFeature(CSKY::FeatureFPUV3_SF) ||
STI.hasFeature(CSKY::FeatureFPUV3_DF);
if (hasAnyFloatExt && STI.hasFeature(CSKY::ModeHardFloat) &&
STI.hasFeature(CSKY::ModeHardFloatABI))
emitAttribute(CSKYAttrs::CSKY_FPU_ABI, CSKYAttrs::FPU_ABI_HARD);
else if (hasAnyFloatExt && STI.hasFeature(CSKY::ModeHardFloat))
emitAttribute(CSKYAttrs::CSKY_FPU_ABI, CSKYAttrs::FPU_ABI_SOFTFP);
else
emitAttribute(CSKYAttrs::CSKY_FPU_ABI, CSKYAttrs::FPU_ABI_SOFT);
unsigned HardFPFlag = 0;
if (STI.hasFeature(CSKY::FeatureFPUV3_HF))
HardFPFlag |= CSKYAttrs::FPU_HARDFP_HALF;
if (STI.hasFeature(CSKY::FeatureFPUV2_SF) ||
STI.hasFeature(CSKY::FeatureFPUV3_SF))
HardFPFlag |= CSKYAttrs::FPU_HARDFP_SINGLE;
if (STI.hasFeature(CSKY::FeatureFPUV2_DF) ||
STI.hasFeature(CSKY::FeatureFPUV3_DF))
HardFPFlag |= CSKYAttrs::FPU_HARDFP_DOUBLE;
if (HardFPFlag != 0) {
emitAttribute(CSKYAttrs::CSKY_FPU_DENORMAL, CSKYAttrs::NEEDED);
emitAttribute(CSKYAttrs::CSKY_FPU_EXCEPTION, CSKYAttrs::NEEDED);
emitTextAttribute(CSKYAttrs::CSKY_FPU_NUMBER_MODULE, "IEEE 754");
emitAttribute(CSKYAttrs::CSKY_FPU_HARDFP, HardFPFlag);
}
}
Reference in New Issue View Git Blame Copy Permalink