radiance · commit

Inline `pushFn`/`pushData` functions

a6d3edee36c56aaf1e6d7913b965ee0f1af521d0cfd66975614e023f1e56c9a7

Alexis Sellier committed 1 month ago 1 parent 0f9c16bc

lib/std/lang/lower.rad +9 -21

            case ast::NodeValue::FnDecl(decl) => {
                if let f = try lowerFnDecl(low, node, decl) {
                    if isRoot and checkAttr(decl.attrs, ast::Attribute::Default) {
                        defaultFnIdx = low.fns.len;
                    }
                    pushFn(low, f);
                    low.fns.append(f, low.allocator);
                }
            }
            case ast::NodeValue::ConstDecl(decl) => {
                try lowerDataDecl(low, node, decl.value, true);
            }

        };
        if fnType.throwList.len > 0 {
            func.returnType = il::Type::W64;
        }
        func.blocks = try lowerFnBody(&mut fnLow, body);
        pushFn(self, func);
        self.fns.append(func, self.allocator);

        let method = resolver::findTraitMethod(traitInfo, mName)
            else panic "lowerInstanceDecl: method not found in trait";

        methodNames[method.index] = qualName;

        values[i] = il::DataValue {
            item: il::DataItem::Fn(methodNames[i]),
            count: 1,
        };
    }
    pushData(self, il::Data {
    self.data.append(il::Data {
        name: vName,
        size: traitInfo.methods.len as u32 * resolver::PTR_SIZE,
        alignment: resolver::PTR_SIZE,
        readOnly: true,
        isUndefined: false,
        values: &values[..traitInfo.methods.len as u32],
    });
    }, self.allocator);
}

/// Check if a function should be lowered.
fn shouldLowerFn(decl: *ast::FnDecl, buildTest: bool) -> bool {
    if checkAttr(decl.attrs, ast::Attribute::Test) {

    let qualName = qualifyName(self, nil, sym.name);
    let mut b = dataBuilder(self.allocator);
    try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);
    let result = dataBuilderFinish(&b);

    pushData(self, il::Data {
    self.data.append(il::Data {
        name: qualName,
        size: layout.size,
        alignment: layout.alignment,
        readOnly,
        isUndefined: result.isUndefined,
        values: result.values,
    });
    }, self.allocator);
}

/// Emit the in-memory representation of a slice header: `{ ptr, len, cap }`.
fn dataSliceHeader(b: *mut DataValueBuilder, dataSym: *[u8], len: u32) {
    dataBuilderPush(b, il::DataValue {

            count: payloadSlotSize - payloadLayout.size
        });
    }
}

/// Add a data item to the lowerer's data list.
// XXX: Inline this.
fn pushData(self: *mut Lowerer, data: il::Data) {
    self.data.append(data, self.allocator);
}

/// Add a function to the lowerer's function list.
// XXX: Inline this.
fn pushFn(self: *mut Lowerer, f: *il::Fn) {
    self.fns.append(f, self.allocator);
}

/// Find an existing string data entry with matching content.
// TODO: Optimize with hash table or remove?
fn findStringData(self: *Lowerer, s: *[u8]) -> ?*[u8] {
    for d in self.data {
        if d.values.len == 1 {

    readOnly: bool,
    values: *[il::DataValue],
    dataPrefix: *[u8]
) -> *[u8] throws (LowerError) {
    let name = nextDeclDataName(self, dataPrefix, self.data.len);
    pushData(self, il::Data { name, size, alignment, readOnly, isUndefined: false, values });
    self.data.append(il::Data { name, size, alignment, readOnly, isUndefined: false, values }, self.allocator);

    return name;
}

/// Find or create read-only string data and return its symbol name.

    if readOnly {
        if let found = findConstData(self.low, values, alignment) {
            dataName = found;
        } else {
            dataName = try nextDataName(self);
            pushData(self.low, il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values });
            self.low.data.append(il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values }, self.low.allocator);
        }
    } else {
        dataName = try nextDataName(self);
        pushData(self.low, il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values });
        self.low.data.append(il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values }, self.low.allocator);
    }

    // Get data address.
    let ptrReg = nextReg(self);
    emit(self, il::Instr::Copy { dst: ptrReg, val: il::Val::DataSym(dataName) });

756	756		case ast::NodeValue::FnDecl(decl) => {
757	757		if let f = try lowerFnDecl(low, node, decl) {
758	758		if isRoot and checkAttr(decl.attrs, ast::Attribute::Default) {
759	759		defaultFnIdx = low.fns.len;
760	760		}
761		-	pushFn(low, f);
	761	+	low.fns.append(f, low.allocator);
762	762		}
763	763		}
764	764		case ast::NodeValue::ConstDecl(decl) => {
765	765		try lowerDataDecl(low, node, decl.value, true);
766	766		}

1053	1053		};
1054	1054		if fnType.throwList.len > 0 {
1055	1055		func.returnType = il::Type::W64;
1056	1056		}
1057	1057		func.blocks = try lowerFnBody(&mut fnLow, body);
1058		-	pushFn(self, func);
	1058	+	self.fns.append(func, self.allocator);
1059	1059
1060	1060		let method = resolver::findTraitMethod(traitInfo, mName)
1061	1061		else panic "lowerInstanceDecl: method not found in trait";
1062	1062
1063	1063		methodNames[method.index] = qualName;

1084	1084		values[i] = il::DataValue {
1085	1085		item: il::DataItem::Fn(methodNames[i]),
1086	1086		count: 1,
1087	1087		};
1088	1088		}
1089		-	pushData(self, il::Data {
	1089	+	self.data.append(il::Data {
1090	1090		name: vName,
1091	1091		size: traitInfo.methods.len as u32 * resolver::PTR_SIZE,
1092	1092		alignment: resolver::PTR_SIZE,
1093	1093		readOnly: true,
1094	1094		isUndefined: false,
1095	1095		values: &values[..traitInfo.methods.len as u32],
1096		-	});
	1096	+	}, self.allocator);
1097	1097		}
1098	1098
1099	1099		/// Check if a function should be lowered.
1100	1100		fn shouldLowerFn(decl: *ast::FnDecl, buildTest: bool) -> bool {
1101	1101		if checkAttr(decl.attrs, ast::Attribute::Test) {

1197	1197		let qualName = qualifyName(self, nil, sym.name);
1198	1198		let mut b = dataBuilder(self.allocator);
1199	1199		try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);
1200	1200		let result = dataBuilderFinish(&b);
1201	1201
1202		-	pushData(self, il::Data {
	1202	+	self.data.append(il::Data {
1203	1203		name: qualName,
1204	1204		size: layout.size,
1205	1205		alignment: layout.alignment,
1206	1206		readOnly,
1207	1207		isUndefined: result.isUndefined,
1208	1208		values: result.values,
1209		-	});
	1209	+	}, self.allocator);
1210	1210		}
1211	1211
1212	1212		/// Emit the in-memory representation of a slice header: `{ ptr, len, cap }`.
1213	1213		fn dataSliceHeader(b: mut DataValueBuilder, dataSym: [u8], len: u32) {
1214	1214		dataBuilderPush(b, il::DataValue {

1529	1529		count: payloadSlotSize - payloadLayout.size
1530	1530		});
1531	1531		}
1532	1532		}
1533	1533
1534		-	/// Add a data item to the lowerer's data list.
1535		-	// XXX: Inline this.
1536		-	fn pushData(self: *mut Lowerer, data: il::Data) {
1537		-	self.data.append(data, self.allocator);
1538		-	}
1539		-
1540		-	/// Add a function to the lowerer's function list.
1541		-	// XXX: Inline this.
1542		-	fn pushFn(self: mut Lowerer, f: il::Fn) {
1543		-	self.fns.append(f, self.allocator);
1544		-	}
1545		-
1546	1534		/// Find an existing string data entry with matching content.
1547	1535		// TODO: Optimize with hash table or remove?
1548	1536		fn findStringData(self: Lowerer, s: [u8]) -> ?*[u8] {
1549	1537		for d in self.data {
1550	1538		if d.values.len == 1 {

1581	1569		readOnly: bool,
1582	1570		values: *[il::DataValue],
1583	1571		dataPrefix: *[u8]
1584	1572		) -> *[u8] throws (LowerError) {
1585	1573		let name = nextDeclDataName(self, dataPrefix, self.data.len);
1586		-	pushData(self, il::Data { name, size, alignment, readOnly, isUndefined: false, values });
	1574	+	self.data.append(il::Data { name, size, alignment, readOnly, isUndefined: false, values }, self.allocator);
1587	1575
1588	1576		return name;
1589	1577		}
1590	1578
1591	1579		/// Find or create read-only string data and return its symbol name.

1702	1690		if readOnly {
1703	1691		if let found = findConstData(self.low, values, alignment) {
1704	1692		dataName = found;
1705	1693		} else {
1706	1694		dataName = try nextDataName(self);
1707		-	pushData(self.low, il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values });
	1695	+	self.low.data.append(il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values }, self.low.allocator);
1708	1696		}
1709	1697		} else {
1710	1698		dataName = try nextDataName(self);
1711		-	pushData(self.low, il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values });
	1699	+	self.low.data.append(il::Data { name: dataName, size, alignment, readOnly, isUndefined: false, values }, self.low.allocator);
1712	1700		}
1713	1701
1714	1702		// Get data address.
1715	1703		let ptrReg = nextReg(self);
1716	1704		emit(self, il::Instr::Copy { dst: ptrReg, val: il::Val::DataSym(dataName) });